diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 95d036381a..3b836d480d 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -849,7 +849,7 @@ jobs: run: test "$(git rev-parse 'HEAD^{tree}')" = "$XBOX_SOURCE_TREE" - name: Install Python test dependencies timeout-minutes: 7 - run: bash tools/ci/install-ubuntu-packages.sh python3-yaml gcc-aarch64-linux-gnu libc6-dev-arm64-cross qemu-user libvulkan-dev mesa-vulkan-drivers + run: bash tools/ci/install-ubuntu-packages.sh python3-yaml gcc-aarch64-linux-gnu libc6-dev-arm64-cross qemu-user libvulkan-dev mesa-vulkan-drivers spirv-tools - name: Resolve the pinned Android NDK run: bash tools/ci/resolve-ndk.sh @@ -879,6 +879,16 @@ jobs: -ldl -o /tmp/test-presenter-shutdown timeout 10 /tmp/test-presenter-shutdown + - name: Fetch the Mali compatibility layer's headers + run: | + set -euo pipefail + sdk=$(sed -n 's/^SDK=//p' tools/venus/ci-build.sh) + bcdec=$(grep -o 'https://raw.githubusercontent.com/iOrange/bcdec/[^ ]*' tools/venus/ci-build.sh) + mkdir -p build/layer-deps/bcdec + git -c advice.detachedHead=false clone -q --depth 1 -b "$sdk" https://github.com/KhronosGroup/Vulkan-Headers.git build/layer-deps/vulkan + git -c advice.detachedHead=false clone -q --depth 1 -b "$sdk" https://github.com/KhronosGroup/SPIRV-Headers.git build/layer-deps/spirv + curl -sSfL -o build/layer-deps/bcdec/bcdec.h "$bcdec" + - name: Steam import and game environment tests run: bash tools/ci/run-python-tests.sh @@ -982,3 +992,35 @@ jobs: if: ${{ always() && github.event_name != 'pull_request' && github.ref == 'refs/heads/main' && needs.announce.result != 'skipped' }} uses: ./.github/workflows/update-catalog.yml secrets: inherit + + retire-tests: + needs: catalog + if: ${{ always() && github.event_name != 'pull_request' && github.ref == 'refs/heads/main' && needs.catalog.result == 'success' }} + runs-on: ubuntu-24.04 + timeout-minutes: 10 + permissions: + contents: read + pull-requests: read + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ github.sha }} + persist-credentials: false + - uses: actions/create-github-app-token@v2 + id: ci-token + with: + app-id: ${{ vars.DROIDDECK_CI_APP_ID }} + private-key: ${{ secrets.DROIDDECK_CI_APP_KEY }} + owner: Droid-Deck + repositories: DroidDeck-CI + - name: Delete the test builds this Preview build replaces + env: + SOURCE_GITHUB_TOKEN: ${{ github.token }} + CI_GITHUB_TOKEN: ${{ steps.ci-token.outputs.token }} + run: python3 tools/release/retire_test_builds.py + + catalog-after-retire: + needs: retire-tests + if: ${{ always() && needs.retire-tests.result == 'success' }} + uses: ./.github/workflows/update-catalog.yml + secrets: inherit diff --git a/.github/workflows/pr-release-cleanup.yml b/.github/workflows/pr-release-cleanup.yml index 3a2580d0e3..d7ad4f080f 100644 --- a/.github/workflows/pr-release-cleanup.yml +++ b/.github/workflows/pr-release-cleanup.yml @@ -40,36 +40,19 @@ jobs: private-key: ${{ secrets.DROIDDECK_CI_APP_KEY }} owner: Droid-Deck repositories: DroidDeck-CI - - name: Delete the test build - if: ${{ steps.state.outputs.closed == 'true' }} - env: - GH_TOKEN: ${{ steps.ci-token.outputs.token }} - PR_NUMBER: ${{ github.event.pull_request.number }} - run: | - set -euo pipefail - retry() { - for attempt in 1 2 3 4; do - "$@" && return 0 - [ "$attempt" = 4 ] || sleep $((attempt * 20)) - done - return 1 - } - existing=$(retry gh api --paginate "repos/Droid-Deck/DroidDeck-CI/releases?per_page=100" --jq '.[].tag_name') - found=0 - for tag in "pr-$PR_NUMBER" "pr-$PR_NUMBER.0"; do - if grep -qxF "$tag" <<<"$existing"; then - retry gh release delete "$tag" -R Droid-Deck/DroidDeck-CI --yes --cleanup-tag - echo "Deleted $tag" - found=1 - fi - done - [ "$found" = 1 ] || echo "No test build for PR #$PR_NUMBER" - - uses: actions/checkout@v4 if: ${{ steps.state.outputs.closed == 'true' }} with: ref: main persist-credentials: false + - name: Delete the test build unless main still needs it + if: ${{ steps.state.outputs.closed == 'true' }} + env: + SOURCE_GITHUB_TOKEN: ${{ github.token }} + CI_GITHUB_TOKEN: ${{ steps.ci-token.outputs.token }} + PR_NUMBER: ${{ github.event.pull_request.number }} + # A merged PR's build stays until a Preview build carries the merge; build.yml and the sweep remove it then. + run: python3 tools/release/retire_test_builds.py --pr "$PR_NUMBER" - name: Retire the Discord PR announcement if: ${{ steps.state.outputs.closed == 'true' }} env: diff --git a/.github/workflows/pr-release-publish.yml b/.github/workflows/pr-release-publish.yml index 85f972a1b4..6c793489c5 100644 --- a/.github/workflows/pr-release-publish.yml +++ b/.github/workflows/pr-release-publish.yml @@ -226,6 +226,8 @@ jobs: publish: needs: [authorize, sign] runs-on: ubuntu-24.04 + outputs: + keep: ${{ steps.publish.outputs.keep }} permissions: actions: read contents: read @@ -322,12 +324,8 @@ jobs: cp pr-packs/* signed/ 2>/dev/null || true gh release upload "$tag" signed/* -R "$repo" --clobber gh release edit "$tag" -R "$repo" --title "PR #$PR_NUMBER" --notes "$notes" --prerelease - keep=$(cd signed && ls | jq -R . | jq -sc .) - gh api "repos/$repo/releases/tags/$tag" | - jq -r --argjson keep "$keep" '.assets[] | select(.name as $n | $keep | index($n) | not) | .id' | - while IFS= read -r id; do - gh api --method DELETE "repos/$repo/releases/assets/$id" >/dev/null - done + # The previous push's files stay until the catalog names these (the prune job), so a download started from the old catalog still finds its APK. + echo "keep=$(cd signed && ls | jq -R . | jq -sc .)" >> "$GITHUB_OUTPUT" published=$(gh release view "$tag" -R "$repo" --json tagName,assets) jq -e --arg tag "$tag" '.tagName == $tag and (.assets | length) > 0' <<<"$published" >/dev/null @@ -417,3 +415,41 @@ jobs: if: ${{ always() && needs.publish.result != 'skipped' }} uses: ./.github/workflows/update-catalog.yml secrets: inherit + + prune: + needs: [authorize, publish, catalog] + if: ${{ always() && needs.publish.result == 'success' && needs.catalog.result == 'success' }} + runs-on: ubuntu-24.04 + timeout-minutes: 15 + steps: + - uses: actions/create-github-app-token@v2 + id: ci-token + with: + app-id: ${{ vars.DROIDDECK_CI_APP_ID }} + private-key: ${{ secrets.DROIDDECK_CI_APP_KEY }} + owner: Droid-Deck + repositories: DroidDeck-CI + - name: Remove the previous push's files + env: + GH_TOKEN: ${{ steps.ci-token.outputs.token }} + PR_NUMBER: ${{ needs.authorize.outputs.pr_number }} + KEEP: ${{ needs.publish.outputs.keep }} + run: | + set -euo pipefail + repo=Droid-Deck/DroidDeck-CI + tag="pr-$PR_NUMBER" + # An app that read the catalog just before it changed may still be starting that download. + sleep 300 + # Delete nothing the published catalog still names. + named=$(gh api -H "Accept: application/vnd.github.raw+json" "repos/$repo/contents/catalog.json?ref=main" | + jq -c --argjson pr "$PR_NUMBER" '[.tests[] | select(.pr == $pr) | .apks[].name]') + stale=$(jq -nr --argjson named "$named" --argjson keep "$KEEP" '$named - $keep | join(" ")') + if [ -n "$stale" ]; then + echo "::warning::The catalog still names $stale; keeping every file of $tag" + exit 0 + fi + gh api "repos/$repo/releases/tags/$tag" | + jq -r --argjson keep "$KEEP" '.assets[] | select(.name as $n | $keep | index($n) | not) | .id' | + while IFS= read -r id; do + gh api --method DELETE "repos/$repo/releases/assets/$id" >/dev/null + done diff --git a/.github/workflows/pr-release-sweep.yml b/.github/workflows/pr-release-sweep.yml index f65777ba6d..b02cf9881b 100644 --- a/.github/workflows/pr-release-sweep.yml +++ b/.github/workflows/pr-release-sweep.yml @@ -26,35 +26,15 @@ jobs: private-key: ${{ secrets.DROIDDECK_CI_APP_KEY }} owner: Droid-Deck repositories: DroidDeck-CI - - name: Delete test builds whose PR is no longer open + - uses: actions/checkout@v4 + with: + ref: main + persist-credentials: false + - name: Delete test builds of closed PRs, and of merged PRs a Preview build carries env: - CI_TOKEN: ${{ steps.ci-token.outputs.token }} - GH_TOKEN: ${{ github.token }} - run: | - set -euo pipefail - retry() { - for attempt in 1 2 3 4; do - "$@" && return 0 - [ "$attempt" = 4 ] || sleep $((attempt * 20)) - done - return 1 - } - tags=$(GH_TOKEN="$CI_TOKEN" retry gh api --paginate "repos/Droid-Deck/DroidDeck-CI/releases?per_page=100" --jq '.[].tag_name' | - grep -E '^pr-[0-9]+(\.0)?$' || true) - failed=0 - for tag in $tags; do - number=${tag#pr-} - number=${number%.0} - state=$(retry gh api "repos/$GITHUB_REPOSITORY/pulls/$number" --jq .state) || { failed=1; continue; } - if [ "$state" != open ]; then - if GH_TOKEN="$CI_TOKEN" retry gh release delete "$tag" -R Droid-Deck/DroidDeck-CI --yes --cleanup-tag; then - echo "Deleted $tag (PR #$number is $state)" - else - failed=1 - fi - fi - done - exit "$failed" + SOURCE_GITHUB_TOKEN: ${{ github.token }} + CI_GITHUB_TOKEN: ${{ steps.ci-token.outputs.token }} + run: python3 tools/release/retire_test_builds.py catalog: needs: sweep diff --git a/README.md b/README.md index 84b6bbcd79..a6b4a1db2f 100644 --- a/README.md +++ b/README.md @@ -80,7 +80,7 @@ DroidDeck is [GPL-3.0](LICENSE). Steam and Proton belong to Valve Corporation. V - The proot fast path orders bindings like [PRoot](https://github.com/proot-me/proot)'s `path/binding.c` (GPL-2.0-or-later). - DiRT 3 and DiRT Showdown keep their telemetry socket the way RoccoC's DiRTTelemetryErrorFix (MIT) does, based on the fix by Carsten Gottschling. - Zink on PowerVR keeps colour textures in colour with Icenowy Zheng's upstream [Mesa](https://gitlab.freedesktop.org/mesa/mesa) fix d55418dae7 (MIT), carried as a runtime patch. -- Games and AppImage, Flatpak and Snap programs such as emulators use [Mesa](https://gitlab.freedesktop.org/mesa/mesa) Turnip's per render pass memory choice. The Steam client and Chromium-based apps keep `TU_DEBUG=sysmem`. +- Games and AppImage, Flatpak and Snap programs such as emulators use `TU_DEBUG=sysmem` by default, as does the Steam client. Turnip sysmem rendering can be turned off in Performance settings, except with the Adreno 710/720 driver, which always uses it. - Black Ops III and Dark Souls Remastered start without [umu-protonfixes](https://github.com/Open-Wine-Components/umu-protonfixes) (BSD-2-Clause), whose `311210.py` and `570940.py` fail under ARM64 Proton. - [ReSkate](https://github.com/Dingo-Shenanigans/ReSkate) (GPL-3.0) by Dingo Shenanigans uses the launch option from its README and D3D12 feature level 12_1. - The arm64 client's sign in was checked by reading Steam's saved token with the `ConnectCache` format from [deadlock-api-ingest](https://github.com/deadlock-api/deadlock-api-ingest). @@ -90,7 +90,7 @@ DroidDeck is [GPL-3.0](LICENSE). Steam and Proton belong to Valve Corporation. V
Stores -- Epic Games and GOG build on [Phobos](https://github.com/phobos665)'s adaptation of [Legendary](https://github.com/legendary-gl/legendary) and [gogdl](https://github.com/Heroic-Games-Launcher/heroic-gogdl). GOG install script registry entries are read the way [Heroic Games Launcher](https://github.com/Heroic-Games-Launcher/HeroicGamesLauncher) (GPL-3.0) reads them. +- Epic Games and GOG build on [Phobos](https://github.com/phobos665)'s adaptation of [Legendary](https://github.com/legendary-gl/legendary) and [gogdl](https://github.com/Heroic-Games-Launcher/heroic-gogdl). GOG install script registry entries are read the way [Heroic Games Launcher](https://github.com/Heroic-Games-Launcher/HeroicGamesLauncher) (GPL-3.0) reads them. GOG cloud storage requests send the Galaxy communication-service User-Agent that gogdl and [Lutris](https://github.com/lutris/lutris) (GPL-3.0) send. - Epic's official Linux launcher preview runs through FEX. That setup is outside Epic's listed Linux support. - The launcher's .deb gets the WebKitGTK and GTK 3 libraries it needs from unmodified [Debian](https://www.debian.org) 13 packages, following [@zooluis](https://github.com/zooluis)'s research in [#2268](https://github.com/Droid-Deck/DroidDeck/pull/2268). - Battle.net is by [@kayakyakr](https://github.com/kayakyakr). It runs Blizzard's own client in Proton (downloaded from Blizzard, not included) and shows key art from the [Battle.net Shop](https://shop.battle.net). Without Steam, its games see the pad as an Xbox 360 controller via `PROTON_SPOOF_STEAMINPUT_VIDPID` in [Proton](https://github.com/ValveSoftware/wine)'s `dlls/winebus.sys`. @@ -98,7 +98,7 @@ DroidDeck is [GPL-3.0](LICENSE). Steam and Proton belong to Valve Corporation. V - Battle.net installs drive Blizzard's Agent the way [@barncastle](https://github.com/barncastle)'s [Battle.Net-Installer](https://github.com/barncastle/Battle.Net-Installer) does, with requests from [wowdev.wiki](https://wowdev.wiki/Agent). Read without taking code: [@mubaraknumann](https://github.com/mubaraknumann)'s [unifideck](https://github.com/mubaraknumann/unifideck), [@djmittens](https://github.com/djmittens)'s [neo-mittens](https://github.com/djmittens/neo-mittens) `bnetswitch`, [@BCD1210](https://github.com/BCD1210)'s [soju](https://github.com/BCD1210/soju) and [Lutris](https://github.com/lutris/lutris)'s `product.db` reader. - World of Warcraft addon imports replace an addon's folder from a temporary copy, as [WowUp](https://github.com/WowUp/WowUp) does, and read flavour folders the way [WoWDeck](https://github.com/sigboe/wowdeck) does. No code from either is used. - The World of Warcraft addon Download window searches [WoWInterface](https://www.wowinterface.com) through its MMOUI API. [CurseForge](https://www.curseforge.com/wow) opens in the user's browser, with no API and no key. -- Xbox games load [@domsvoboda](https://github.com/domsvoboda)'s [xodus-nexus](https://github.com/domsvoboda/xodus-nexus) modules (LGPL-2.1-or-later), including `wintypes.dll`. Minecraft's GameInput setup was checked against [@Wyze3306](https://github.com/Wyze3306)'s [BedrockOnLinux](https://github.com/Wyze3306/BedrockOnLinux) (MIT). +- Xbox games load [@domsvoboda](https://github.com/domsvoboda)'s [xodus-nexus](https://github.com/domsvoboda/xodus-nexus) modules (LGPL-2.1-or-later), including `wintypes.dll`. Content licensing sends delegation-compact device tickets in the licensing wire form, following the [nexus-backend](https://github.com/domsvoboda/nexus-backend) commit `27c335e`. Minecraft's GameInput setup was checked against [@Wyze3306](https://github.com/Wyze3306)'s [BedrockOnLinux](https://github.com/Wyze3306/BedrockOnLinux) (MIT). - The Xbox Cloud Gaming player uses the WebRTC client of [@unknownskl](https://github.com/unknownskl)'s [Greenlight](https://github.com/unknownskl/greenlight) (MIT), and its offer tweaks and sharpening follow [@redphx](https://github.com/redphx)'s [Better xCloud](https://github.com/redphx/better-xcloud) (MIT). See `tools/xcloud-player/NOTICE.md`. - The itch.io butler pack ships butler's `7z.so`, itch.io's build of [7-Zip](https://www.7-zip.org) by Igor Pavlov (LGPL-2.1, unRAR restriction on RAR code), unmodified. Other archives use Apache Commons Compress and the runtime's bsdtar (libarchive). - The Store uses [Flatpak](https://github.com/flatpak/flatpak) (LGPL-2.1) through DroidDeck's own bubblewrap shim. Chromium and Electron apps start directly, since [zypak](https://github.com/refi64/zypak) by [@refi64](https://github.com/refi64) (BSD-3-Clause) always uses Flatpak's spawn portal. diff --git a/app/build.gradle b/app/build.gradle index 7f992a5f42..af25c45878 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -295,6 +295,16 @@ if (uvcDir) { } tasks.named('preBuild').configure { dependsOn(stageRuntimeAssets) } +android.sourceSets.main.java.srcDir(rootProject.file('shortcuts/src/protocol/java')) +def stageShortcuts = tasks.register('stageShortcuts', Copy) { + dependsOn(':shortcuts:assembleRelease') + from(project(':shortcuts').layout.buildDirectory.file('outputs/apk/release/shortcuts-release.apk')) + into(layout.buildDirectory.dir('shortcutsAssets')) + rename { 'shortcuts.apk' } +} +android.sourceSets.main.assets.srcDir(layout.buildDirectory.dir('shortcutsAssets')) +tasks.named('preBuild').configure { dependsOn(stageShortcuts) } + def stageGogNotices = tasks.register('stageGogNotices', Copy) { from(layout.projectDirectory.dir('src/main/rust/stores/vendor/xdelta3')) { include 'LICENSE', 'README.droiddeck.md' } into(layout.buildDirectory.dir('gogNotices/licenses/xdelta3')) diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 172da8d450..2adbfc86cd 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -89,21 +89,11 @@ android:label="@string/steam_wall_label" android:theme="@android:style/Theme.Translucent.NoTitleBar" android:exported="true" /> - + - + - - - - - - #include #include +#include #include #include #include @@ -157,6 +158,8 @@ struct FakeController { bool closed = false; bool needs_keyframe = true; bool mouse = false; + int playing_ff = -1; + pid_t owner = getpid(); ~FakeController() { if (ring) munmap(ring, mapping_size); @@ -195,6 +198,7 @@ static constexpr size_t kSnapshotButtonCount = namespace Logger { void init(); +void log(const char *message, ...); } static void controller_fork_prepare(); @@ -286,6 +290,68 @@ static bool fake_vibration_enabled() { return config().vibration_enabled; } static bool fake_xbox360_identity() { return config().xbox360_identity; } static bool fake_uinput_enabled() { return config().uinput_enabled; } +static bool process_is_steam_client(); + +// Steam and its Remote Play client write the same shared slots; the caller's mutex serialises its own threads. +// Without the lock Steam stays the only writer, as before streaming_client could open these devices. The wait +// is bounded because a session freeze can stop the holder, and callers wait with controller_mutex held. +class ProcessSlotLock { +public: + ProcessSlotLock(int &fd, const char *name, int timeout_ms) : fd_(fd) { + int saved_errno = errno; + if (fd_ < 0) { + std::string path = std::string(fake_hook_dir()) + "/." + name + ".lock"; + fd_ = fd = static_cast(syscall(SYS_openat, AT_FDCWD, path.c_str(), O_CREAT | O_RDWR | O_CLOEXEC, 0600)); + } + int error = fd_ < 0 ? errno : 0; + if (fd_ >= 0) { + struct timespec start, now, pause = {0, 1000 * 1000}; + clock_gettime(CLOCK_MONOTONIC, &start); + for (;;) { + if (flock(fd_, LOCK_EX | LOCK_NB) == 0) { + locked_ = true; + break; + } + if (errno == EINTR) continue; + if (errno != EWOULDBLOCK) { + error = errno; + break; + } + clock_gettime(CLOCK_MONOTONIC, &now); + if ((now.tv_sec - start.tv_sec) * 1000 + (now.tv_nsec - start.tv_nsec) / 1000000 >= timeout_ms) { + busy_ = true; + break; + } + nanosleep(&pause, nullptr); + } + } + if (busy_) { + static std::atomic waits; + unsigned n = ++waits; + if ((n & (n - 1)) == 0) Logger::log("lock: %s still held after %d ms, skipped (x%u)\n", name, timeout_ms, n); + } else if (!locked_) { + static std::atomic noted{false}; + if (!noted.exchange(true)) + Logger::log("lock: %s not taken (%s)%s\n", name, strerror(error), + process_is_steam_client() ? "" : "; this process leaves the shared slots alone"); + } + errno = saved_errno; + } + ~ProcessSlotLock() { + int saved_errno = errno; + if (locked_) flock(fd_, LOCK_UN); + errno = saved_errno; + } + bool may_write() const { return locked_ || (!busy_ && process_is_steam_client()); } + ProcessSlotLock(const ProcessSlotLock &) = delete; + ProcessSlotLock &operator=(const ProcessSlotLock &) = delete; + +private: + int fd_; + bool locked_ = false; + bool busy_ = false; +}; + static bool ring_paths_loaded = false; static int next_ff_id = 0; @@ -411,22 +477,49 @@ __attribute__((visibility("hidden"))) static void send_ff_effect(const struct ff send_vibration(effect.u.periodic.magnitude, effect.u.periodic.magnitude, duration, slot); } +static std::unordered_map &ff_players() { + static auto *players = new std::unordered_map(); + return *players; +} + +__attribute__((visibility("hidden"))) static void ff_played(FakeController &controller, int id) { + controller.playing_ff = id; + controller.owner = getpid(); + ff_players()[controller.slot] = &controller; +} + +__attribute__((visibility("hidden"))) static bool ff_release(FakeController &controller) { + auto player = ff_players().find(controller.slot); + bool current = player != ff_players().end() && player->second == &controller; + if (current) ff_players().erase(player); + controller.playing_ff = -1; + return current; +} + __attribute__((visibility("hidden"))) static void -check_ff_event(const struct input_event *ev, uint16_t slot) { +check_ff_event(const struct input_event *ev, FakeController &controller) { if (ev->type != EV_FF) return; + uint16_t slot = static_cast(controller.slot); int id = ev->code; if (ev->value > 0) { auto it = ff_effects().find(id); if (it == ff_effects().end()) return; send_ff_effect(it->second, slot); + ff_played(controller, id); } else { send_vibration(0, 0, 0, slot); + ff_release(controller); } } +__attribute__((visibility("hidden"))) static void stop_ff(FakeController &controller) { + bool playing = controller.playing_ff >= 0 && controller.owner == getpid(); + if (ff_release(controller) && playing) send_vibration(0, 0, 0, static_cast(controller.slot)); +} + __attribute__((visibility("hidden"))) char * from_real_to_fake_path(const char *pathname) { const char *event = strrchr(pathname, '/') + 1; @@ -1185,10 +1278,13 @@ struct DeckImu { uint32_t controls; uint32_t pad_type; uint32_t latency; + uint32_t remote_imu_mode; + uint32_t remote_imu_pid; }; static_assert(offsetof(DeckImu, pad_type) == FAKE_INPUT_RING_PAD_TYPE_OFFSET, "DeckImu::pad_type matches FakeInputWriter and the ring reader"); static_assert(offsetof(DeckImu, latency) == 48, "DeckImu::latency matches FakeInputWriter"); +static_assert(offsetof(DeckImu, remote_imu_mode) == 52, "DeckImu::remote_imu_mode matches FakeInputWriter"); static constexpr uint32_t LATENCY_CONTROLLER = 1, LATENCY_TOUCH = 2; static constexpr int LOW_LATENCY_REPORT_INTERVAL_US = 1000; static constexpr uint32_t DECK_EXTRA_L4 = 1, DECK_EXTRA_R4 = 2, DECK_EXTRA_L5 = 4, @@ -1395,6 +1491,25 @@ __attribute__((visibility("hidden"))) static bool process_is_steam_client() { return known == 1; } +// Steam's Remote Play client reads the controller itself, in its own streaming_client process. +__attribute__((visibility("hidden"))) static bool process_reads_pads() { + static int known; + if (known == 0) { + bool reader = process_is_steam_client(); + if (!reader) { + char exe[PATH_MAX]; + ssize_t length = readlink("/proc/self/exe", exe, sizeof(exe) - 1); + if (length > 0) { + exe[length] = '\0'; + const char *name = strrchr(exe, '/'); + reader = !strcmp(name ? name + 1 : exe, "streaming_client"); + } + } + known = reader ? 1 : -1; + } + return known == 1; +} + __attribute__((constructor)) static void log_client_start() { config(); if (process_is_steam_client()) @@ -1439,7 +1554,7 @@ __attribute__((visibility("hidden"))) static bool is_withdrawn_pad_path(const ch free(fake); return !exposed; } - return number == 0 || !process_is_steam_client(); + return number == 0 || !process_reads_pads(); } static bool fake_pad_withdrawn(const FakeController &fake) { @@ -1654,7 +1769,7 @@ __attribute__((visibility("hidden"))) static void *sony_report_thread(void *arg) __attribute__((visibility("hidden"))) static int open_deck_hidraw(int flags, uint8_t sony = 0) { const char *path = sony == 4 ? DS4_HIDRAW_PATH : sony == 5 ? DUALSENSE_HIDRAW_PATH : DECK_HIDRAW_PATH; static auto my_open = reinterpret_cast(dlsym(RTLD_NEXT, "open")); - if (!process_is_steam_client()) { + if (!process_reads_pads()) { Logger::log("deck: %s refused: not the Steam client\n", path); errno = ENOENT; return -1; @@ -1863,7 +1978,7 @@ __attribute__((visibility("hidden"))) static void *triton_pad_thread(void *arg) __attribute__((visibility("hidden"))) static int open_triton_hidraw(int flags, bool emulated) { static auto my_open = reinterpret_cast(dlsym(RTLD_NEXT, "open")); - if (!process_is_steam_client()) { + if (!process_reads_pads()) { errno = ENOENT; return -1; } @@ -2004,15 +2119,19 @@ __attribute__((visibility("hidden"))) static bool touch_plugged() { } __attribute__((visibility("hidden"))) static bool is_touch_hidraw_path(const char *pathname) { - return pathname && !strcmp(pathname, TOUCH_HIDRAW_PATH) && process_is_steam_client() && touch_ring(); + return pathname && !strcmp(pathname, TOUCH_HIDRAW_PATH) && process_reads_pads() && touch_ring(); } +static std::mutex touch_state_mutex; +static int touch_state_lock_fd = -1; + template __attribute__((visibility("hidden"))) static void touch_state(F &&write) { TouchRingFile *ring = touch_ring(); if (!ring) return; - static std::mutex mutex; - std::lock_guard guard(mutex); + std::lock_guard guard(touch_state_mutex); + ProcessSlotLock slot(touch_state_lock_fd, "touch-state", 20); + if (!slot.may_write()) return; __atomic_fetch_add(&ring->state_seq, 1, __ATOMIC_ACQ_REL); write(*ring); __atomic_fetch_add(&ring->state_seq, 1, __ATOMIC_ACQ_REL); @@ -2264,9 +2383,10 @@ __attribute__((visibility("hidden"))) static void *pad_type_thread(void *) { struct timespec settle = {0, 300 * 1000 * 1000}; nanosleep(&settle, nullptr); int added = pad_type_uevent(now, "add"); - if (was != PAD_TYPE_XBOX) poke_hidraw_watchers(pad_type_minor(was)); - if (now != PAD_TYPE_XBOX) poke_hidraw_watchers(pad_type_minor(now)); - if (was == PAD_TYPE_XBOX || now == PAD_TYPE_XBOX) { + bool shared = process_is_steam_client(); + if (shared && was != PAD_TYPE_XBOX) poke_hidraw_watchers(pad_type_minor(was)); + if (shared && now != PAD_TYPE_XBOX) poke_hidraw_watchers(pad_type_minor(now)); + if (shared && (was == PAD_TYPE_XBOX || now == PAD_TYPE_XBOX)) { std::string node = std::string(fake_hook_dir()) + "/event0"; std::string aside = std::string(fake_hook_dir()) + "/.event0-switching"; if (rename(node.c_str(), aside.c_str()) == 0) { @@ -2285,7 +2405,7 @@ __attribute__((visibility("hidden"))) static void *pad_type_thread(void *) { __attribute__((constructor)) static void start_pad_type_watch() { config(); - if (!process_is_steam_client() || !fake_deck_enabled()) return; + if (!process_reads_pads() || !fake_deck_enabled()) return; pthread_t thread; if (pthread_create(&thread, nullptr, pad_type_thread, nullptr) == 0) pthread_detach(thread); } @@ -2306,7 +2426,7 @@ __attribute__((visibility("hidden"))) static void *touch_plug_thread(void *) { __attribute__((constructor)) static void start_touch_controller() { config(); - if (!process_is_steam_client() || !touch_ring()) return; + if (!process_reads_pads() || !touch_ring()) return; pthread_t thread; if (pthread_create(&thread, nullptr, touch_plug_thread, nullptr) == 0) pthread_detach(thread); } @@ -2413,8 +2533,13 @@ __attribute__((visibility("hidden"))) static void publish_imu_mode(const DeckHid std::string path = get_ring_path_for_slot(0); int fd = path.empty() ? -1 : my_open(path.c_str(), O_WRONLY | O_CLOEXEC); if (fd < 0) return; - uint32_t value = 0x80000000u | static_cast(mode); - if (pwrite(fd, &value, sizeof(value), FAKE_INPUT_RING_SIZE + offsetof(DeckImu, imu_mode)) != sizeof(value)) + // Steam and its Remote Play client each keep their own word, so one turning motion off does not starve the + // other; Android reads motion while either wants it. The pid lets it ignore a Remote Play client that has gone. + uint32_t value[2] = {0x80000000u | static_cast(mode), static_cast(getpid())}; + bool steam = process_is_steam_client(); + size_t length = steam ? sizeof(value[0]) : sizeof(value); + off_t offset = FAKE_INPUT_RING_SIZE + (steam ? offsetof(DeckImu, imu_mode) : offsetof(DeckImu, remote_imu_mode)); + if (pwrite(fd, value, length, offset) != static_cast(length)) Logger::log("deck: imu mode not published (%s)\n", strerror(errno)); syscall(SYS_close, fd); } @@ -2619,7 +2744,10 @@ __attribute__((visibility("hidden"))) static void triton_queue_output(DeckHidraw auto *shared = reinterpret_cast(reinterpret_cast(triton.ring) + TRITON_SHARED_OFFSET); if (__atomic_load_n(&shared->magic, __ATOMIC_ACQUIRE) != TRITON_SHARED_MAGIC) return; static std::mutex one_at_a_time; + static int lock_fd = -1; std::lock_guard guard(one_at_a_time); + ProcessSlotLock slot(lock_fd, "triton-output", TRITON_OUTPUT_TIMEOUT_MS * 2); + if (!slot.may_write()) return; for (int waited = 0; static_cast(__atomic_load_n(&shared->output_seq, __ATOMIC_ACQUIRE)) != __atomic_load_n(&shared->output_ack, __ATOMIC_ACQUIRE) && @@ -2651,7 +2779,13 @@ __attribute__((visibility("hidden"))) static int triton_get_feature(DeckHidraw & } auto *shared = reinterpret_cast(reinterpret_cast(triton.ring) + TRITON_SHARED_OFFSET); static std::mutex one_at_a_time; + static int lock_fd = -1; std::lock_guard guard(one_at_a_time); + ProcessSlotLock slot(lock_fd, "triton-feature", TRITON_FEATURE_TIMEOUT_MS); + if (!slot.may_write()) { + errno = EIO; + return -1; + } uint8_t report_id = report[0]; __atomic_store_n(&shared->get_report_id, report_id, __ATOMIC_RELAXED); uint64_t request = __atomic_add_fetch(&shared->get_request, 1, __ATOMIC_RELEASE); @@ -2839,7 +2973,7 @@ __attribute__((visibility("hidden"))) static int ioctl_triton(DeckHidraw &triton __attribute__((visibility("hidden"))) static std::string note_sys_failure(int dirfd, const char *pathname) { int saved_errno = errno; std::string path; - if (saved_errno == ENOENT || !pathname || !process_is_steam_client()) { + if (saved_errno == ENOENT || !pathname || !process_reads_pads()) { errno = saved_errno; return path; } @@ -2878,7 +3012,7 @@ __attribute__((visibility("hidden"))) static std::string note_sys_failure(int di __attribute__((visibility("hidden"))) static std::string deck_listing_for(const char *path) { const char *listing = deck_listing_dir(); - if (!path || !listing || errno != EACCES || !fake_deck_enabled() || !process_is_steam_client()) return {}; + if (!path || !listing || errno != EACCES || !fake_deck_enabled() || !process_reads_pads()) return {}; std::string p(path); while (p.size() > 1 && p.back() == '/') p.pop_back(); int which = p == "/sys" ? 0 : p == "/sys/class" ? 1 : p == "/sys/bus" ? 2 : -1; @@ -2947,7 +3081,7 @@ EXPORT int statx(int dirfd, const char *path, int flags, unsigned mask, struct s constexpr unsigned unique_mount_id = 0x4000; if (result == 0 && (mask & STATX_MNT_ID) && !(buf->stx_mask & (STATX_MNT_ID | unique_mount_id)) && fake_deck_enabled() && - process_is_steam_client() && deck_device_library(__builtin_return_address(0))) { + process_reads_pads() && deck_device_library(__builtin_return_address(0))) { bool recovered = deck_mount_id_from_fdinfo(dirfd, path, flags, buf); static std::atomic noted_success{false}, noted_failure{false}; if (!(recovered ? noted_success : noted_failure).exchange(true)) @@ -3136,7 +3270,7 @@ template static int fake_stat_path(const char *pathname, S *statbuf, Real real) { if (is_withdrawn_pad_path(pathname) || ((is_deck_hidraw_path(pathname) || is_triton_hidraw_path(pathname) || is_triton_pad_path(pathname) || - sony_pad_path(pathname)) && !process_is_steam_client())) { + sony_pad_path(pathname)) && !process_reads_pads())) { errno = ENOENT; return -1; } @@ -3261,9 +3395,9 @@ EXPORT int fstat(int fd, struct stat *buf) { EXPORT int access(const char *pathname, int mode) { static auto my_access = reinterpret_cast(dlsym(RTLD_NEXT, "access")); if (fake_uinput_enabled() && is_uinput_path(pathname)) return 0; - if (is_deck_hidraw_path(pathname) && process_is_steam_client()) return 0; + if (is_deck_hidraw_path(pathname) && process_reads_pads()) return 0; if ((is_triton_hidraw_path(pathname) || is_triton_pad_path(pathname) || sony_pad_path(pathname)) && - process_is_steam_client()) + process_reads_pads()) return 0; if (is_touch_hidraw_path(pathname)) return 0; if (is_withdrawn_pad_path(pathname) || is_deck_hidraw_path(pathname) || is_triton_hidraw_path(pathname) || @@ -3302,9 +3436,9 @@ EXPORT int access(const char *pathname, int mode) { EXPORT int faccessat(int dirfd, const char *pathname, int mode, int flags) { static auto my_faccessat = reinterpret_cast(dlsym(RTLD_NEXT, "faccessat")); if (fake_uinput_enabled() && is_uinput_path(pathname)) return 0; - if (is_deck_hidraw_path(pathname) && process_is_steam_client()) return 0; + if (is_deck_hidraw_path(pathname) && process_reads_pads()) return 0; if ((is_triton_hidraw_path(pathname) || is_triton_pad_path(pathname) || sony_pad_path(pathname)) && - process_is_steam_client()) + process_reads_pads()) return 0; if (is_touch_hidraw_path(pathname)) return 0; if (is_withdrawn_pad_path(pathname) || is_deck_hidraw_path(pathname) || is_triton_hidraw_path(pathname) || @@ -3371,7 +3505,7 @@ EXPORT int inotify_add_watch(int fd, const char *pathname, uint32_t mask) { pathname = fake_path; } else if (!strcmp(pathname, "/dev/input")) { pathname = fake_hook_dir(); - } else if (!strcmp(pathname, "/dev") && fake_deck_enabled() && process_is_steam_client()) { + } else if (!strcmp(pathname, "/dev") && fake_deck_enabled() && process_reads_pads()) { std::string events = hidraw_event_dir(); mkdir(events.c_str(), 0700); my_inotify_add_watch(fd, events.c_str(), mask); @@ -3657,10 +3791,12 @@ EXPORT int ioctl(int fd, ioctl_request_t op, ...) { effect->id = next_ff_id++; ff_effects()[effect->id] = *effect; send_ff_effect(*effect, static_cast(event_number)); + ff_played(*controller->second, effect->id); return 0; } else if (type == 0x45 && number == 0x81) { int id = (intptr_t)argp; ff_effects().erase(id); + if (controller->second->playing_ff == id) stop_ff(*controller->second); return 0; } else if (type == 0x45 && number == 0x84) { int max_effects = 16; @@ -3740,6 +3876,7 @@ EXPORT int close(int fd) { if (controller != controller_map().end()) { Logger::log("Removing controller, fd %d event %s\n", controller->first, controller->second->event ? controller->second->event : "(unknown)"); + stop_ff(*controller->second); controller->second->closed = true; controller_map().erase(fd); } @@ -3937,12 +4074,8 @@ EXPORT ssize_t write(int fd, const void *buf, size_t count) { return -1; } - const struct input_event *ev = nullptr; - uint16_t slot = static_cast(controller->second->slot); - if (count == sizeof(struct input_event)) { - ev = static_cast(buf); - check_ff_event(ev, slot); - } + if (count == sizeof(struct input_event)) + check_ff_event(static_cast(buf), *controller->second); return static_cast(count); } @@ -3982,14 +4115,10 @@ EXPORT ssize_t writev(int fd, const struct iovec *iov, int iovcnt) { return -1; } - uint16_t slot = static_cast(controller->second->slot); ssize_t total = 0; for (int i = 0; i < iovcnt; i++) { - if (iov[i].iov_len == sizeof(struct input_event)) { - const struct input_event *ev = - static_cast(iov[i].iov_base); - check_ff_event(ev, slot); - } + if (iov[i].iov_len == sizeof(struct input_event)) + check_ff_event(static_cast(iov[i].iov_base), *controller->second); total += static_cast(iov[i].iov_len); } return total; diff --git a/app/src/main/cpp/framegen/VkDispatchTable.h b/app/src/main/cpp/framegen/VkDispatchTable.h new file mode 100644 index 0000000000..b5aab97d14 --- /dev/null +++ b/app/src/main/cpp/framegen/VkDispatchTable.h @@ -0,0 +1,106 @@ +#pragma once +#include +#include + +struct VkTable { + + PFN_vkCreateInstance CreateInstance; + + PFN_vkDestroyInstance DestroyInstance; + PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices; + PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties; + PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties; + PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR; + PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR; + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR; + PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties; + PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR; + PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties; + PFN_vkGetPhysicalDeviceFeatures2 GetPhysicalDeviceFeatures2; + PFN_vkCreateDevice CreateDevice; + PFN_vkDestroySurfaceKHR DestroySurfaceKHR; + PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR; + + PFN_vkGetDeviceProcAddr GetDeviceProcAddr; + PFN_vkDestroyDevice DestroyDevice; + PFN_vkGetDeviceQueue GetDeviceQueue; + PFN_vkDeviceWaitIdle DeviceWaitIdle; + PFN_vkCreateSwapchainKHR CreateSwapchainKHR; + PFN_vkDestroySwapchainKHR DestroySwapchainKHR; + PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR; + PFN_vkAcquireNextImageKHR AcquireNextImageKHR; + PFN_vkQueuePresentKHR QueuePresentKHR; + PFN_vkQueueSubmit QueueSubmit; + PFN_vkCreateQueryPool CreateQueryPool; + PFN_vkDestroyQueryPool DestroyQueryPool; + PFN_vkCmdResetQueryPool CmdResetQueryPool; + PFN_vkCmdWriteTimestamp CmdWriteTimestamp; + PFN_vkGetQueryPoolResults GetQueryPoolResults; + PFN_vkCreateRenderPass CreateRenderPass; + PFN_vkDestroyRenderPass DestroyRenderPass; + PFN_vkCreateFramebuffer CreateFramebuffer; + PFN_vkDestroyFramebuffer DestroyFramebuffer; + PFN_vkCreateImageView CreateImageView; + PFN_vkDestroyImageView DestroyImageView; + PFN_vkCreateImage CreateImage; + PFN_vkDestroyImage DestroyImage; + PFN_vkCreateBuffer CreateBuffer; + PFN_vkDestroyBuffer DestroyBuffer; + PFN_vkAllocateMemory AllocateMemory; + PFN_vkFreeMemory FreeMemory; + PFN_vkMapMemory MapMemory; + PFN_vkFlushMappedMemoryRanges FlushMappedMemoryRanges; + PFN_vkBindBufferMemory BindBufferMemory; + PFN_vkBindImageMemory BindImageMemory; + PFN_vkGetBufferMemoryRequirements GetBufferMemoryRequirements; + PFN_vkGetImageMemoryRequirements GetImageMemoryRequirements; + PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout; + PFN_vkDestroyDescriptorSetLayout DestroyDescriptorSetLayout; + PFN_vkCreateDescriptorPool CreateDescriptorPool; + PFN_vkDestroyDescriptorPool DestroyDescriptorPool; + PFN_vkAllocateDescriptorSets AllocateDescriptorSets; + PFN_vkFreeDescriptorSets FreeDescriptorSets; + PFN_vkUpdateDescriptorSets UpdateDescriptorSets; + PFN_vkCreatePipelineLayout CreatePipelineLayout; + PFN_vkDestroyPipelineLayout DestroyPipelineLayout; + PFN_vkCreateShaderModule CreateShaderModule; + PFN_vkDestroyShaderModule DestroyShaderModule; + PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines; + PFN_vkDestroyPipeline DestroyPipeline; + PFN_vkCreateCommandPool CreateCommandPool; + PFN_vkDestroyCommandPool DestroyCommandPool; + PFN_vkAllocateCommandBuffers AllocateCommandBuffers; + PFN_vkFreeCommandBuffers FreeCommandBuffers; + PFN_vkBeginCommandBuffer BeginCommandBuffer; + PFN_vkEndCommandBuffer EndCommandBuffer; + PFN_vkResetCommandBuffer ResetCommandBuffer; + PFN_vkCmdBeginRenderPass CmdBeginRenderPass; + PFN_vkCmdEndRenderPass CmdEndRenderPass; + PFN_vkCmdBindPipeline CmdBindPipeline; + PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets; + PFN_vkCmdDraw CmdDraw; + PFN_vkCmdPushConstants CmdPushConstants; + PFN_vkCmdSetViewport CmdSetViewport; + PFN_vkCmdSetScissor CmdSetScissor; + PFN_vkCmdPipelineBarrier CmdPipelineBarrier; + PFN_vkCmdCopyImage CmdCopyImage; + PFN_vkCmdBlitImage CmdBlitImage; + + PFN_vkCmdDispatch CmdDispatch; + PFN_vkCreateComputePipelines CreateComputePipelines; + PFN_vkUnmapMemory UnmapMemory; + PFN_vkCmdClearColorImage CmdClearColorImage; + PFN_vkResetDescriptorPool ResetDescriptorPool; + PFN_vkCmdCopyBufferToImage CmdCopyBufferToImage; + PFN_vkCreateSampler CreateSampler; + PFN_vkDestroySampler DestroySampler; + PFN_vkCreateSemaphore CreateSemaphore; + PFN_vkDestroySemaphore DestroySemaphore; + PFN_vkCreateFence CreateFence; + PFN_vkDestroyFence DestroyFence; + PFN_vkWaitForFences WaitForFences; + PFN_vkResetFences ResetFences; + PFN_vkGetFenceStatus GetFenceStatus; + + PFN_vkGetAndroidHardwareBufferPropertiesANDROID GetAndroidHardwareBufferPropertiesANDROID; +}; diff --git a/app/src/main/cpp/framegen/VulkanRendererContext.h b/app/src/main/cpp/framegen/VulkanRendererContext.h deleted file mode 100644 index 7cbbcdf42f..0000000000 --- a/app/src/main/cpp/framegen/VulkanRendererContext.h +++ /dev/null @@ -1,680 +0,0 @@ -#pragma once -#include -#include -#include -struct VkTable { - - PFN_vkCreateInstance CreateInstance; - - PFN_vkDestroyInstance DestroyInstance; - PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices; - PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties; - PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties; - PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR; - PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR; - PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR; - PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties; - PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR; - PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties; - PFN_vkGetPhysicalDeviceFeatures2 GetPhysicalDeviceFeatures2; - PFN_vkCreateDevice CreateDevice; - PFN_vkDestroySurfaceKHR DestroySurfaceKHR; - PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR; - - PFN_vkGetDeviceProcAddr GetDeviceProcAddr; - PFN_vkDestroyDevice DestroyDevice; - PFN_vkGetDeviceQueue GetDeviceQueue; - PFN_vkDeviceWaitIdle DeviceWaitIdle; - PFN_vkCreateSwapchainKHR CreateSwapchainKHR; - PFN_vkDestroySwapchainKHR DestroySwapchainKHR; - PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR; - PFN_vkAcquireNextImageKHR AcquireNextImageKHR; - PFN_vkQueuePresentKHR QueuePresentKHR; - PFN_vkQueueSubmit QueueSubmit; - PFN_vkCreateQueryPool CreateQueryPool; - PFN_vkDestroyQueryPool DestroyQueryPool; - PFN_vkCmdResetQueryPool CmdResetQueryPool; - PFN_vkCmdWriteTimestamp CmdWriteTimestamp; - PFN_vkGetQueryPoolResults GetQueryPoolResults; - PFN_vkCreateRenderPass CreateRenderPass; - PFN_vkDestroyRenderPass DestroyRenderPass; - PFN_vkCreateFramebuffer CreateFramebuffer; - PFN_vkDestroyFramebuffer DestroyFramebuffer; - PFN_vkCreateImageView CreateImageView; - PFN_vkDestroyImageView DestroyImageView; - PFN_vkCreateImage CreateImage; - PFN_vkDestroyImage DestroyImage; - PFN_vkCreateBuffer CreateBuffer; - PFN_vkDestroyBuffer DestroyBuffer; - PFN_vkAllocateMemory AllocateMemory; - PFN_vkFreeMemory FreeMemory; - PFN_vkMapMemory MapMemory; - PFN_vkFlushMappedMemoryRanges FlushMappedMemoryRanges; - PFN_vkBindBufferMemory BindBufferMemory; - PFN_vkBindImageMemory BindImageMemory; - PFN_vkGetBufferMemoryRequirements GetBufferMemoryRequirements; - PFN_vkGetImageMemoryRequirements GetImageMemoryRequirements; - PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout; - PFN_vkDestroyDescriptorSetLayout DestroyDescriptorSetLayout; - PFN_vkCreateDescriptorPool CreateDescriptorPool; - PFN_vkDestroyDescriptorPool DestroyDescriptorPool; - PFN_vkAllocateDescriptorSets AllocateDescriptorSets; - PFN_vkFreeDescriptorSets FreeDescriptorSets; - PFN_vkUpdateDescriptorSets UpdateDescriptorSets; - PFN_vkCreatePipelineLayout CreatePipelineLayout; - PFN_vkDestroyPipelineLayout DestroyPipelineLayout; - PFN_vkCreateShaderModule CreateShaderModule; - PFN_vkDestroyShaderModule DestroyShaderModule; - PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines; - PFN_vkDestroyPipeline DestroyPipeline; - PFN_vkCreateCommandPool CreateCommandPool; - PFN_vkDestroyCommandPool DestroyCommandPool; - PFN_vkAllocateCommandBuffers AllocateCommandBuffers; - PFN_vkFreeCommandBuffers FreeCommandBuffers; - PFN_vkBeginCommandBuffer BeginCommandBuffer; - PFN_vkEndCommandBuffer EndCommandBuffer; - PFN_vkResetCommandBuffer ResetCommandBuffer; - PFN_vkCmdBeginRenderPass CmdBeginRenderPass; - PFN_vkCmdEndRenderPass CmdEndRenderPass; - PFN_vkCmdBindPipeline CmdBindPipeline; - PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets; - PFN_vkCmdDraw CmdDraw; - PFN_vkCmdPushConstants CmdPushConstants; - PFN_vkCmdSetViewport CmdSetViewport; - PFN_vkCmdSetScissor CmdSetScissor; - PFN_vkCmdPipelineBarrier CmdPipelineBarrier; - PFN_vkCmdCopyImage CmdCopyImage; - PFN_vkCmdBlitImage CmdBlitImage; - - PFN_vkCmdDispatch CmdDispatch; - PFN_vkCreateComputePipelines CreateComputePipelines; - PFN_vkUnmapMemory UnmapMemory; - PFN_vkCmdClearColorImage CmdClearColorImage; - PFN_vkResetDescriptorPool ResetDescriptorPool; - PFN_vkCmdCopyBufferToImage CmdCopyBufferToImage; - PFN_vkCreateSampler CreateSampler; - PFN_vkDestroySampler DestroySampler; - PFN_vkCreateSemaphore CreateSemaphore; - PFN_vkDestroySemaphore DestroySemaphore; - PFN_vkCreateFence CreateFence; - PFN_vkDestroyFence DestroyFence; - PFN_vkWaitForFences WaitForFences; - PFN_vkResetFences ResetFences; - PFN_vkGetFenceStatus GetFenceStatus; - - PFN_vkGetAndroidHardwareBufferPropertiesANDROID GetAndroidHardwareBufferPropertiesANDROID; -}; - -#include -#include -#define WLOG_TAG "DroidDeck_Renderer" -#define RLOG(...) if(verboseLog) __android_log_print(ANDROID_LOG_DEBUG,WLOG_TAG,__VA_ARGS__) -#define RLOG_E(...) __android_log_print(ANDROID_LOG_ERROR,WLOG_TAG,__VA_ARGS__) -#define SCANOUT_LOG(...) __android_log_print(ANDROID_LOG_DEBUG,"DroidDeck_Scanout",__VA_ARGS__) - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "../scanout/ScanoutContext.h" - -#include "lsfg/lsfg_probe.h" -#include -#include - -namespace lsfg { class Engine; } -namespace ddfg { class Engine; } - -static constexpr uint32_t MAX_FRAMES_IN_FLIGHT = 2; - - - - -struct SgsrPushConstants { - float ndc[4]; - float viewportInfo[4]; - float edgeSharpness; -}; -struct NisPushConstants { - float ndc[4]; - float viewportInfo[4]; - float sharpness; -}; -struct EasuPushConstants { - float ndc[4]; - uint32_t con0[4], con1[4], con2[4], con3[4]; - float outW, outH; -}; -struct RcasPushConstants { - float ndc[4]; - uint32_t con[4]; - float outW, outH; -}; - - -struct CasPushConstants { - float ndc[4]; - float resolution[2]; - float sharpness; - float _pad; -}; -struct HdrPushConstants { - float ndc[4]; - float resolution[2]; -}; - - -struct FxaaPushConstants { - float ndc[4]; - float resolution[2]; -}; -struct ToonPushConstants { - float ndc[4]; - float resolution[2]; -}; -struct ColorPushConstants { - float ndc[4]; - float brightness; - float contrast; - float gamma; - float saturation; - - -}; -struct NtscPushConstants { - float ndc[4]; - float resolution[2]; - float frameCount; -}; -struct CrtPushConstants { - float ndc[4]; - float resolution[2]; -}; -struct DebandPushConstants { - float ndc[4]; - float resolution[2]; - float strength; -}; - -class VulkanRendererContext { -public: - VulkanRendererContext(ANativeWindow* window, int cWidth, int cHeight, void* adrenotoolsHandle = nullptr, - bool lsfgVk11Compat = false); - ~VulkanRendererContext(); - - void onSurfaceResized(int width, int height); - void setTransform(float ox, float oy, float sx, float sy); - void setClipRegion(int x, int y, int w, int h); - void updatePointerPosition(short x, short y); - void updateWindowContent(int64_t id, void* pixels, short w, short h, short stride, int x, int y); - void updateWindowContentAHB(int64_t id, AHardwareBuffer* ahb, short w, short h, int x, int y); - void updateCursorImage(void* pixels, short w, short h, short hotX, short hotY); - void setCursorVisible(bool visible); - void setRenderList(const int64_t* ids, const int* xs, const int* ys, int count); - void removeWindow(int64_t id); - void clearBackbuffer() {} - void beginBatch() {} - void endBatch() {} - void initScanout(); - void destroyScanout(); - void applyScanoutBuffer(); - void initScanoutFromWindows(ANativeWindow* gameWin, ANativeWindow* cursorWin); - void scanoutSetDst(int x, int y, int w, int h); - void scanoutSetBuffer(AHardwareBuffer* ahb, int x, int y, int w, int h, int fenceFd = -1); - void scanoutSetCursorImage(void* pixels, short w, short h, short stride); - void scanoutSetCursorPos(short x, short y, short hotX, short hotY); - ScanoutContext scanout; - std::atomic& scanoutActive = scanout.scanoutActive; - std::atomic& gameFrameDelivered = scanout.gameFrameDelivered; - std::atomic surfaceDetached{false}; - - void detachSurface(); - bool reattachSurface(ANativeWindow* newWindow); - - bool verboseLog = true; - void setVerboseLog(bool v) { verboseLog = v; scanout.setVerboseLog(v); } - void dumpRendererInfo(); - - std::string adrenoDriverPath; - std::string adrenoDriverName; - std::string adrenoNativeLibDir; - void* vulkanHandle = nullptr; - std::atomic scanoutBlackFrameDone{false}; - PFN_vkGetInstanceProcAddr gipa = nullptr; - VkTable vk_ = {}; - void loadCustomDriver(); - void loadInstanceDispatch(); - void loadDeviceDispatch(); - - void setFilterMode(int mode); - void setUpscaler(int mode); - void setHqDownscale(bool enabled); - void setCas(bool enabled, int sharpness); - void setHdr(bool enabled); - void setDeband(bool enabled, int strength); - void setUpscaleSharpness(int sharpness); - void setFxaa(bool enabled); - void setToon(bool enabled); - void setCrt(bool enabled); - void setNtsc(bool enabled); - void setColorGrade(float brightness, float contrast, float gamma, float saturation); - void setSwapRB(bool enabled); - void setPresentMode(VkPresentModeKHR mode); - std::vector getSupportedPresentModes() const; - - const lsfg::Caps& lsfgCaps() const { return lsfgCaps_; } - - void setFrameGenArmed(bool armed, int multiplier); - bool frameGenArmed() const { return fgArmed_.load(std::memory_order_relaxed); } - void frameGenStats(float out[6]) const; - int frameGenProblem() const; - void setLsfgCachePath(const char* path); - static constexpr int32_t kFgCaptureGame = -1; - void setFrameGenTuning(float flowScale, float refreshHz, int32_t captureHeight = 0); - void setFrameGenEngine(int kind); - void setDdFgTuning(int model, int perfPreset); - -private: - struct WinTex { - VkImage img = VK_NULL_HANDLE; - VkDeviceMemory mem = VK_NULL_HANDLE; - VkImageView view = VK_NULL_HANDLE; - VkDescriptorSet ds = VK_NULL_HANDLE; - VkBuffer stg = VK_NULL_HANDLE; - VkDeviceMemory stgMem = VK_NULL_HANDLE; - void* mapped = nullptr; - VkDeviceSize cap = 0; - int w = 0; - int h = 0; - bool dirty = false; - bool isAHB = false; - bool needsTransition = false; - AHardwareBuffer* ahb = nullptr; - }; - - struct RenderEntry { int64_t id; int x, y; }; - struct DrawEntry { - VkImage img = VK_NULL_HANDLE; - VkDescriptorSet ds = VK_NULL_HANDLE; - VkBuffer upload = VK_NULL_HANDLE; - int x=0, y=0, w=0, h=0; - bool needsTransition = false; - bool isAHB = false; - }; - - ANativeWindow* window; - int surfaceWidth, surfaceHeight, containerWidth, containerHeight; - std::atomic clipRegionX{0}, clipRegionY{0}, clipRegionW{0}, clipRegionH{0}; - void* adrenotoolsHandle = nullptr; - bool lsfgVk11Compat_ = false; - int filterMode = 0; - bool swapRB = false; - float maxAnisotropy = 1.0f; - bool cubicSupported = false; - VkPhysicalDeviceMemoryProperties memProperties{}; - VkPresentModeKHR requestedPresentMode = VK_PRESENT_MODE_FIFO_KHR; - uint32_t graphicsQueueFamilyIndex = 0; - std::vector availablePresentModes; - - std::unordered_map texMap; - - std::unordered_map ahbImportCache; - std::unordered_map> windowAhbs; - - std::vector deleteQueue; - std::vector renderList; - - std::vector frameDraws; - std::vector frameAhbTransitions; - std::vector framePreUpload; - std::vector framePostUpload; - - - std::atomic pointerX{0}, pointerY{0}; - float sceneOffsetX=0.f, sceneOffsetY=0.f, sceneScaleX=1.f, sceneScaleY=1.f; - - std::atomic cursorVisible{false}; - short cursorHotX=0, cursorHotY=0, cursorTexW=0, cursorTexH=0; - std::vector cursorPixels; - std::atomic isCursorImageDirty{false}; - std::atomic cursorMoved{false}; - - VkImage cursorImg = VK_NULL_HANDLE; - VkDeviceMemory cursorMem = VK_NULL_HANDLE; - VkImageView cursorView = VK_NULL_HANDLE; - VkDescriptorSet cursorDS = VK_NULL_HANDLE; - VkBuffer cursorStg = VK_NULL_HANDLE; - VkDeviceMemory cursorStgM = VK_NULL_HANDLE; - void* cursorStgP = nullptr; - VkDeviceSize cursorStgC = 0; - VkDeviceSize cursorUploadSize = 0; - - VkInstance instance; - VkSurfaceKHR surface; - VkPhysicalDevice physicalDevice; - VkDevice device; - VkQueue graphicsQueue; - VkSwapchainKHR swapchain = VK_NULL_HANDLE; - VkFormat swapchainFmt; - VkExtent2D swapchainExt; - - std::vector swapchainImages; - std::vector swapchainViews; - std::vector swapchainFBs; - - VkRenderPass renderPass = VK_NULL_HANDLE; - VkDescriptorSetLayout dsLayout = VK_NULL_HANDLE; - VkPipelineLayout pipeLayout = VK_NULL_HANDLE; - - VkPipeline pipeline = VK_NULL_HANDLE; - - int upscalerMode = 0; - bool hqDownscale = false; - - bool casEnabled = false; - int casSharpness = 60; - bool hdrEnabled = false; - float upscaleSharpness01 = 0.75f; - - bool debandEnabled = false; - int debandStrength = 100; - - bool fxaaEnabled = false; - bool toonEnabled = false; - bool crtEnabled = false; - bool ntscEnabled = false; - bool colorEnabled = false; - float colorBrightness = 0.0f; - float colorContrast = 0.0f; - float colorGamma = 1.0f; - float colorSaturation = 1.0f; - uint32_t ntscFrameCounter = 0; - - VkSampler upscaleSampler = VK_NULL_HANDLE; - - struct CompositeTarget { - VkImage img = VK_NULL_HANDLE; - VkDeviceMemory mem = VK_NULL_HANDLE; - VkImageView view = VK_NULL_HANDLE; - VkImageView storageView = VK_NULL_HANDLE; - VkFramebuffer fb = VK_NULL_HANDLE; - VkDescriptorSet ds = VK_NULL_HANDLE; - }; - static constexpr uint32_t kMaxCompositeTargets = 7; - - std::vector compositeTargets; - VkRenderPass compositeRenderPass = VK_NULL_HANDLE; - uint32_t compositeW = 0, compositeH = 0; - uint32_t compositeIndex = 0; - bool compositeArmed = false; - bool swapchainTransferDst = false; - - std::atomic fgArmed_{false}; - std::atomic fgMultiplier_{0}; - std::atomic fgFlowScale_{1.0f}; - std::atomic fgRefreshHz_{0.0f}; - std::atomic fgConfigDirty_{true}; - std::atomic fgCaptureHeight_{0}; - void compositeExtentFor(uint32_t& w, uint32_t& h) const; - VkExtent2D renderExtent() const { - if (compositeActive() && (compositeW != swapchainExt.width || compositeH != swapchainExt.height)) - return VkExtent2D{compositeW, compositeH}; - return swapchainExt; - } - void recordCompositeToSwapchainTransfer(VkCommandBuffer cb, VkImage src, uint32_t imgIdx); - - bool createCompositeRenderPass(); - bool ensureCompositeTargets(uint32_t w, uint32_t h, uint32_t count); - void destroyCompositeTargets(); - bool compositeActive() const; - VkRenderPass targetRenderPass() const; - VkFramebuffer targetFramebuffer(uint32_t imgIdx) const; - void copyCompositeToSwapchain(VkCommandBuffer cb, uint32_t imgIdx); - - VkRenderPass cursorOverlayRenderPass = VK_NULL_HANDLE; - struct CursorOverlay { - bool draw = false; - float ox = 0, oy = 0, sx = 0, sy = 0, cw = 0, ch = 0; - short ptrX = 0, ptrY = 0, hotX = 0, hotY = 0, w = 0, h = 0; - }; - CursorOverlay cursorOverlay_{}; - - bool createCursorOverlayRenderPass(); - void recordCursorOverlay(VkCommandBuffer cb, uint32_t imgIdx); - bool cursorDrawnPerPresent() const; - - - - - - - - static constexpr uint32_t kMaxPresentsPerFrame = 4; - struct FrameGenPlan { - uint32_t generations = 0; - uint32_t presents = 1; - uint32_t imgIdx[kMaxPresentsPerFrame] = {}; - }; - FrameGenPlan fgPlan_{}; - std::unique_ptr lsfgEngine_; - uint64_t fgSourceFrames_ = 0; - std::string lsfgCachePath_; - bool lsfgEngineTried_ = false; - std::unique_ptr ddfgEngine_; - bool ddfgEngineTried_ = false; - std::atomic fgEngineKind_{0}; - std::atomic fgModel_{4}; - std::atomic fgPerfPreset_{1}; - bool ensureDdFgEngine(); - bool fgCapsOk() const; - - uint32_t syncSlot(uint32_t k) const { return currentFrame * kMaxPresentsPerFrame + k; } - void recreateSyncObjects(); - uint32_t fgAcquireFailLog_ = 0; - - float fgPresentedRate_ = 0.0f; - float fgSourceRate_ = 0.0f; - uint32_t fgSourceAccum_ = 0; - uint32_t fgPresentAccum_ = 0; - std::chrono::steady_clock::time_point fgRateWindowStart_{}; - bool fgRateWindowOpen_ = false; - void trackPresentedRate(uint32_t presents); - - bool ensureLsfgEngine(); - uint32_t cmdSlot(uint32_t k) const { return currentFrame * kMaxPresentsPerFrame + k; } - void recordFrameGenProcess(VkCommandBuffer cb); - void recordFrameGenGeneration(VkCommandBuffer cb, uint32_t g); - - VkQueryPool fgQueryPool_ = VK_NULL_HANDLE; - bool fgTimestampsOk_ = false; - float fgTimestampPeriodNs_ = 0.0f; - bool fgQueryPending_[MAX_FRAMES_IN_FLIGHT] = {}; - uint32_t fgQueryGens_[MAX_FRAMES_IN_FLIGHT] = {}; - float fgChainMsPerGen_ = -1.0f; - uint32_t fgChainLogCount_ = 0; - void ensureFgQueryPool(); - void destroyFgQueryPool(); - void readFgQueryResult(); - - VkFormat offscreenFmt = VK_FORMAT_R8G8B8A8_UNORM; - VkRenderPass offscreenRenderPass = VK_NULL_HANDLE; - VkPipelineLayout postPipeLayout = VK_NULL_HANDLE; - VkPipeline sgsrPipeline = VK_NULL_HANDLE; - VkPipeline nisPipeline = VK_NULL_HANDLE; - VkPipeline sgsrQualityPipeline = VK_NULL_HANDLE; - VkPipeline easuPipeline = VK_NULL_HANDLE; - VkPipeline rcasPipeline = VK_NULL_HANDLE; - VkPipeline downscalePipeline = VK_NULL_HANDLE; - - - - VkPipeline casPipelineOff = VK_NULL_HANDLE; - VkPipeline casPipelineSwap = VK_NULL_HANDLE; - VkPipeline hdrPipelineOff = VK_NULL_HANDLE; - VkPipeline hdrPipelineSwap = VK_NULL_HANDLE; - VkPipeline fxaaPipelineOff = VK_NULL_HANDLE; - VkPipeline fxaaPipelineSwap = VK_NULL_HANDLE; - VkPipeline toonPipelineOff = VK_NULL_HANDLE; - VkPipeline toonPipelineSwap = VK_NULL_HANDLE; - VkPipeline colorPipelineOff = VK_NULL_HANDLE; - VkPipeline colorPipelineSwap = VK_NULL_HANDLE; - VkPipeline ntscPipelineOff = VK_NULL_HANDLE; - VkPipeline ntscPipelineSwap = VK_NULL_HANDLE; - VkPipeline crtPipelineOff = VK_NULL_HANDLE; - VkPipeline crtPipelineSwap = VK_NULL_HANDLE; - VkPipeline debandPipelineSwap = VK_NULL_HANDLE; - - VkImage offscreenImg = VK_NULL_HANDLE; - VkDeviceMemory offscreenMem = VK_NULL_HANDLE; - VkImageView offscreenView = VK_NULL_HANDLE; - VkFramebuffer offscreenFB = VK_NULL_HANDLE; - VkDescriptorSet offscreenDS = VK_NULL_HANDLE; - int offscreenW = 0, offscreenH = 0; - - VkImage midImg = VK_NULL_HANDLE; - VkDeviceMemory midMem = VK_NULL_HANDLE; - VkImageView midView = VK_NULL_HANDLE; - VkFramebuffer midFB = VK_NULL_HANDLE; - VkDescriptorSet midDS = VK_NULL_HANDLE; - int midW = 0, midH = 0; - - VkImage fx1Img = VK_NULL_HANDLE; - VkDeviceMemory fx1Mem = VK_NULL_HANDLE; - VkImageView fx1View = VK_NULL_HANDLE; - VkFramebuffer fx1FB = VK_NULL_HANDLE; - VkDescriptorSet fx1DS = VK_NULL_HANDLE; - int fx1W = 0, fx1H = 0; - - VkImage fx2Img = VK_NULL_HANDLE; - VkDeviceMemory fx2Mem = VK_NULL_HANDLE; - VkImageView fx2View = VK_NULL_HANDLE; - VkFramebuffer fx2FB = VK_NULL_HANDLE; - VkDescriptorSet fx2DS = VK_NULL_HANDLE; - int fx2W = 0, fx2H = 0; - - struct UpscaleFrame { - bool active = false; - int mode = 0; - int outX = 0, outY = 0, outW = 0, outH = 0; - bool cas = false; - bool hdr = false; - bool fxaa = false; - bool toon = false; - bool color = false; - bool ntsc = false; - bool crt = false; - bool deband = false; - SgsrPushConstants sgsrPC{}; - NisPushConstants nisPC{}; - EasuPushConstants easuPC{}; - RcasPushConstants rcasPC{}; - CasPushConstants casPC{}; - HdrPushConstants hdrPC{}; - FxaaPushConstants fxaaPC{}; - ToonPushConstants toonPC{}; - ColorPushConstants colorPC{}; - NtscPushConstants ntscPC{}; - CrtPushConstants crtPC{}; - DebandPushConstants debandPC{}; - } upFrame; - - VkCommandPool cmdPool = VK_NULL_HANDLE; - std::vector cmdBufs; - - std::vector imgAvailSems; - std::vector renderDoneSems; - std::vector inFlightFences; - std::vector imgInFlight; - uint32_t currentFrame = 0; - - VkSampler sampler = VK_NULL_HANDLE; - VkDescriptorPool winTexPool = VK_NULL_HANDLE; - - std::atomic needsRender{false}; - std::thread renderThread; - std::atomic isRunning{false}; - std::atomic fbResized{false}; - std::mutex renderMutex; - std::mutex dirtyMutex; - std::condition_variable dirtyCV; - std::shared_mutex frameMutex; - - void createInstance(); - void createSurface(); - void pickPhysicalDevice(); - lsfg::Caps lsfgCaps_{}; - - void createLogicalDevice(); - void createSwapchain(); - void createRenderPass(); - void createDSLayout(); - void createPipeline(bool blend, VkPipeline& out); - void createFramebuffers(); - void createCmdPool(); - void createSampler(); - void createUpscaleSampler(); - void createOffscreenRenderPass(); - void createPostPipelines(); - VkPipeline createPostPipeline(const uint32_t* fragCode, size_t fragSz, VkRenderPass rp); - bool createColorTarget(int w, int h, VkImage& img, VkDeviceMemory& mem, - VkImageView& view, VkFramebuffer& fb, VkDescriptorSet& ds); - void destroyColorTarget(VkImage& img, VkDeviceMemory& mem, VkImageView& view, - VkFramebuffer& fb, VkDescriptorSet& ds); - bool ensureOffscreen(int w, int h); - bool ensureMid(int w, int h); - bool ensureFx1(int w, int h); - bool ensureFx2(int w, int h); - void recordUpscalePasses(VkCommandBuffer cb, uint32_t imgIdx, - const std::vector& draws, bool cursorDrawn, - short ptrX, short ptrY, short curHotX, short curHotY, - short curW, short curH, - float ox, float oy, float sx, float sy, - float cw, float ch); - void planUpscaleFrame(); - void createWinTexPool(); - void createCursorPipeline(); - void createCursorDS(); - void createCmdBufs(); - void createSyncObjects(); - void cleanupSwapchain(); - - bool createWinTexResources(WinTex& wt, int w, int h); - bool importAHBToWinTex(WinTex& wt, AHardwareBuffer* ahb); - void cleanupAllAHBCache(); - void flushDeleteQueue(); - void destroyWinTex(WinTex& wt); - void ensureCursorTex(short w, short h); - void cleanupCursorTex(); - void ensureCursorStaging(VkDeviceSize sz); - - void recordCmdBuf(VkCommandBuffer cb, uint32_t imgIdx, - const std::vector& draws, - std::vector& ahbTransitions, - std::vector& preUpload, - std::vector& postUpload, - VkBuffer cursorUpload, bool hasCursorUpload, - float ox, float oy, float sx, float sy, float cw, float ch, - short ptrX, short ptrY, short curHotX, short curHotY, - short curW, short curH, bool curVis); - void renderLoop(); - void renderFrame(); - - uint32_t findMemType(uint32_t filter, VkMemoryPropertyFlags props); - void createBuffer(VkDeviceSize sz, VkBufferUsageFlags usage, - VkMemoryPropertyFlags props, VkBuffer& buf, VkDeviceMemory& mem); - VkCommandBuffer beginOneTime(); - void endOneTime(VkCommandBuffer cmd); - void transition(VkCommandBuffer cmd, VkImage img, - VkImageLayout oldL, VkImageLayout newL, - VkAccessFlags srcA, VkAccessFlags dstA, - VkPipelineStageFlags srcS, VkPipelineStageFlags dstS); - VkShaderModule makeShader(const uint32_t* code, size_t sz); -}; diff --git a/app/src/main/cpp/framegen/ddfg/ddfg_vkd.cpp b/app/src/main/cpp/framegen/ddfg/ddfg_vkd.cpp index ba8a7b3ad0..b2021e8c16 100644 --- a/app/src/main/cpp/framegen/ddfg/ddfg_vkd.cpp +++ b/app/src/main/cpp/framegen/ddfg/ddfg_vkd.cpp @@ -1,5 +1,5 @@ #include "ddfg_vkd.h" -#include "../VulkanRendererContext.h" +#include "../VkDispatchTable.h" #include bool ddfgVkdInit(const VkTable& table, ddfg::DeviceDispatch& dd, ddfg::InstanceDispatch& id) { diff --git a/app/src/main/cpp/framegen/lsfg/lsfg_probe.cpp b/app/src/main/cpp/framegen/lsfg/lsfg_probe.cpp index 36ed36cedf..ee38916e78 100644 --- a/app/src/main/cpp/framegen/lsfg/lsfg_probe.cpp +++ b/app/src/main/cpp/framegen/lsfg/lsfg_probe.cpp @@ -1,6 +1,6 @@ #include "lsfg_probe.h" -#include "../VulkanRendererContext.h" +#include "../VkDispatchTable.h" #include #include diff --git a/app/src/main/cpp/framegen/lsfg/lsfg_vkd.cpp b/app/src/main/cpp/framegen/lsfg/lsfg_vkd.cpp index b89807077a..a4014a9e58 100644 --- a/app/src/main/cpp/framegen/lsfg/lsfg_vkd.cpp +++ b/app/src/main/cpp/framegen/lsfg/lsfg_vkd.cpp @@ -1,6 +1,6 @@ #include "lsfg_vkd.h" -#include "../VulkanRendererContext.h" +#include "../VkDispatchTable.h" #include diff --git a/app/src/main/cpp/scanout/ScanoutContext.h b/app/src/main/cpp/scanout/ScanoutContext.h deleted file mode 100644 index 0981366408..0000000000 --- a/app/src/main/cpp/scanout/ScanoutContext.h +++ /dev/null @@ -1,82 +0,0 @@ -#pragma once - - -#include -#include -#include -#include -#include -#include -#include - -#ifndef SCANOUT_LOG -#define SCANOUT_LOG(...) __android_log_print(ANDROID_LOG_DEBUG,"DroidDeck_Scanout",__VA_ARGS__) -#endif - -class ScanoutContext { -public: - bool loadApi(); - void initFromWindow(ANativeWindow* win = nullptr); - void initFromWindows(ANativeWindow* gameWin, ANativeWindow* cursorWin); - void destroy(); - - void setBuffer(AHardwareBuffer* ahb, int x, int y, int w, int h, int fenceFd = -1); - - bool setCursorImage(void* pixels, short w, short h, short stride); - bool setCursorPos(short x, short y, short hotX, short hotY); - void applyPendingCursor(); - - void setDst(int x, int y, int w, int h); - void setContainerSize(int w, int h) { containerWidth = w; containerHeight = h; } - void setSurfaceSize(int w, int h) { surfaceWidth = w; surfaceHeight = h; } - void setFallbackWindow(ANativeWindow* win) { window = win; } - void setVerboseLog(bool v) { verboseLog = v; } - - bool isActive() const { return scanoutActive.load(); } - bool isGameFrameDelivered() const { - return gameFrameDelivered.load(std::memory_order_acquire); - } - void* debugGameSC() const { return scanoutGameSC; } - - std::atomic scanoutActive{false}; - std::atomic gameFrameDelivered{false}; - -private: - ANativeWindow* window = nullptr; - bool verboseLog = true; - - int surfaceWidth = 0, surfaceHeight = 0, containerWidth = 0, containerHeight = 0; - - void* scanoutGameSC = nullptr; - void* scanoutCursorSC = nullptr; - void* scanoutCursorBuf = nullptr; - int32_t scanoutCursorBufW = 0; - int32_t scanoutCursorBufH = 0; - - void* scanoutTx = nullptr; - void* scanoutGameTx = nullptr; - - ARect scanoutLastSrc{}, scanoutLastDst{}; - bool scanoutGeoDirty = true; - bool scanoutVisShown = false; - bool scanoutApiLoaded = false; - - void* fnSCCreateFromWin = nullptr; - void* fnSCRelease = nullptr; - void* fnSTCreate = nullptr; - void* fnSTDelete = nullptr; - void* fnSTApply = nullptr; - void* fnSTSetBuffer = nullptr; - void* fnSTSetZOrder = nullptr; - void* fnSTSetVisibility = nullptr; - void* fnSTSetGeometry = nullptr; - - int32_t scanoutDstX = 0, scanoutDstY = 0, scanoutDstW = 0, scanoutDstH = 0; - bool gameScVisible = false; - - std::mutex scanoutMutex; - - short pendingCursorX = 0, pendingCursorY = 0, pendingCursorHotX = 0, pendingCursorHotY = 0; - bool cursorPosDirty = false; - bool cursorImageDirty = false; -}; diff --git a/app/src/main/cpp/waylandcomp/src/compositor.c b/app/src/main/cpp/waylandcomp/src/compositor.c index 3510ea29a3..39a20bc7ac 100644 --- a/app/src/main/cpp/waylandcomp/src/compositor.c +++ b/app/src/main/cpp/waylandcomp/src/compositor.c @@ -127,6 +127,9 @@ static int log_budget(void) { #ifndef BTN_RIGHT #define BTN_RIGHT 0x111 #endif +#ifndef BTN_MIDDLE +#define BTN_MIDDLE 0x112 +#endif #define INPUT_SPACE_W 1920 #define INPUT_SPACE_H 1080 @@ -582,6 +585,13 @@ int droiddeck_cursor_snapshot(int *out, int cap) { } struct active_touch { struct surface *surface; int pointer_fallback; }; static struct active_touch g_touch_points[MAX_TOUCH_POINTS]; +#define PEN_IN (1 << 0) +#define PEN_TIP (1 << 1) +#define PEN_RIGHT (1 << 2) +#define PEN_MIDDLE (1 << 3) +#define PEN_BIT(button) (1 << ((button) - BTN_LEFT)) +struct pen_state { int in, buttons; struct surface *grab; }; +static struct pen_state g_pen; static void touch_cancel_surface(struct surface *surface); static struct surface *g_grab; static void publish_query_state(void); @@ -1339,6 +1349,7 @@ static void surface_resource_destroy(struct wl_resource *r) { if (g_grab == s) g_grab = NULL; if (g_key_target == s) g_key_target = NULL; if (g_ime_click == s) g_ime_click = NULL; + if (g_pen.grab == s) g_pen.grab = NULL; droiddeck_text_input_surface_gone(r); if (g_desktop == s) { g_desktop = NULL; droiddeck_log("desktop", "the desktop closed"); } if (g_hud_surface == s) { g_hud_surface = NULL; droiddeck_on_game_surface(NULL, NULL); } @@ -3240,14 +3251,14 @@ static void deliver_pointer(const struct input_msg *m) { pointer_event(x, y, m->p1 == 1 ? 0 : BTN_LEFT, m->p1 == 0); } -static void input_output_to_scene(int px, int py, double *x, double *y) { +static void input_output_to_scene(double px, double py, double *x, double *y) { int w, h, ow, oh; scene_size(&w, &h); vkp_output_size(&ow, &oh); if (ow <= 0 || oh <= 0 || - !vkp_output_to_scene((double)px * ow / INPUT_SPACE_W, (double)py * oh / INPUT_SPACE_H, x, y)) { - *x = (double)px * w / INPUT_SPACE_W; - *y = (double)py * h / INPUT_SPACE_H; + !vkp_output_to_scene(px * ow / INPUT_SPACE_W, py * oh / INPUT_SPACE_H, x, y)) { + *x = px * w / INPUT_SPACE_W; + *y = py * h / INPUT_SPACE_H; } if (*x < 0) *x = 0; if (*y < 0) *y = 0; @@ -3476,6 +3487,57 @@ static void deliver_touch(const struct input_msg *m) { publish_query_state(); } +static void pen_log_target(void) { + static struct wl_client *said; + for (int i = 0; i < g_nptrs; i++) { + if (!g_ptrs[i].focus) continue; + struct wl_client *client = wl_resource_get_client(g_ptrs[i].focus); + if (client != said && log_budget()) { + char name[160]; + describe(wl_resource_get_user_data(g_ptrs[i].focus), name, sizeof(name)); + droiddeck_log("pen", "%s gets the pen as the pointer", name); + } + said = client; + return; + } +} + +static int pen_buttons(int flags) { + int held = 0; + if (flags & PEN_TIP) held |= PEN_BIT(BTN_LEFT); + if (flags & PEN_RIGHT) held |= PEN_BIT(BTN_RIGHT); + if (flags & PEN_MIDDLE) held |= PEN_BIT(BTN_MIDDLE); + return held; +} + +static void pen_release(int buttons) { + for (uint32_t button = BTN_LEFT; button <= BTN_MIDDLE; button++) + if (buttons & PEN_BIT(button)) pointer_button(button, 0); +} + +static void deliver_pen(const struct input_msg *m) { + if (!(m->p1 & PEN_IN)) { + pen_release(g_pen.buttons); + if (g_pen.in) g_raw_valid = 0; + memset(&g_pen, 0, sizeof(g_pen)); + return; + } + int held = pen_buttons(m->p1); + if (!g_pen.in) g_raw_valid = 0; + g_pen.in = 1; + double x, y; + input_output_to_scene(m->p2 / 256.0, m->p3 / 256.0, &x, &y); + if (g_pen.buttons) g_grab = g_pen.grab; + if (!pointer_locked_for_cursor()) pointer_event(x, y, 0, 0); + for (uint32_t button = BTN_LEFT; button <= BTN_MIDDLE; button++) + if (held & ~g_pen.buttons & PEN_BIT(button)) pointer_button(button, 1); + g_pen.grab = g_grab; + pen_release(g_pen.buttons & ~held); + if (held) g_grab = g_pen.grab; + g_pen.buttons = held; + pen_log_target(); +} + static void key_event(uint32_t evdev, int pressed); struct wl_resource *droiddeck_ime_target(void); static void deliver_key(const struct input_msg *m) { @@ -3627,6 +3689,7 @@ static int on_input_readable(int fd, uint32_t mask, void *data) { case 10: break; case 11: axis_event(m.p1, m.p2, 0); break; case 12: axis_event(m.p1, m.p2, 1); break; + case 13: deliver_pen(&m); break; case 20: stream_take(); break; case 21: if (!m.p1) stream_forget_all(); schedule_render(); break; case 22: schedule_render(); break; @@ -3666,6 +3729,13 @@ void droiddeck_wayland_send_touch(int action, int pointer_id, int x, int y) { (void)n; } +void droiddeck_wayland_send_pen(int flags, int x, int y) { + if (g_input_pipe[1] < 0) return; + struct input_msg m = { 13, flags, x, y, 0 }; + ssize_t n = write(g_input_pipe[1], &m, sizeof(m)); + (void)n; +} + void droiddeck_wayland_send_key(int evdev, int state) { if (g_input_pipe[1] < 0) return; struct input_msg m = { 1, evdev, state, 0, 0 }; diff --git a/app/src/main/cpp/waylandcomp/src/framegen_engine.cpp b/app/src/main/cpp/waylandcomp/src/framegen_engine.cpp index 8558ae3d39..be1b03e34a 100644 --- a/app/src/main/cpp/waylandcomp/src/framegen_engine.cpp +++ b/app/src/main/cpp/waylandcomp/src/framegen_engine.cpp @@ -8,7 +8,7 @@ #include -#include "VulkanRendererContext.h" +#include "VkDispatchTable.h" #include "lsfg/lsfg_engine.h" #include "lsfg/lsfg_probe.h" #include "lsfg/lsfg_vkd.h" diff --git a/app/src/main/cpp/waylandcomp/src/vk_loader.c b/app/src/main/cpp/waylandcomp/src/vk_loader.c index 0cda81cd05..1a9fc1c923 100644 --- a/app/src/main/cpp/waylandcomp/src/vk_loader.c +++ b/app/src/main/cpp/waylandcomp/src/vk_loader.c @@ -6,6 +6,7 @@ #include #include #include +#include #define TAG "DroidDeckWayland" @@ -45,6 +46,13 @@ int vk_loader_open(const char *driver_path, const char *library_name, return g_vk.CreateInstance ? 0 : -1; } +void vk_loader_close(void) { + if (g_handle) dlclose(g_handle); + g_handle = NULL; + g_gip = NULL; + memset(&g_vk, 0, sizeof(g_vk)); +} + PFN_vkGetInstanceProcAddr vk_loader_gipa(void) { return g_gip; } void vk_loader_load_instance(VkInstance instance) { diff --git a/app/src/main/cpp/waylandcomp/src/vk_loader.h b/app/src/main/cpp/waylandcomp/src/vk_loader.h index 2f5701dd6b..2742a1b82a 100644 --- a/app/src/main/cpp/waylandcomp/src/vk_loader.h +++ b/app/src/main/cpp/waylandcomp/src/vk_loader.h @@ -6,7 +6,7 @@ #define VK_GLOBAL_FUNCS(X) X(CreateInstance) X(EnumerateInstanceExtensionProperties) #define VK_INSTANCE_FUNCS(X) \ - X(EnumeratePhysicalDevices) X(GetPhysicalDeviceProperties) \ + X(DestroyInstance) X(EnumeratePhysicalDevices) X(GetPhysicalDeviceProperties) \ X(GetPhysicalDeviceQueueFamilyProperties) X(GetPhysicalDeviceSurfaceSupportKHR) \ X(GetPhysicalDeviceSurfaceCapabilitiesKHR) X(GetPhysicalDeviceSurfaceFormatsKHR) \ X(CreateAndroidSurfaceKHR) X(DestroySurfaceKHR) X(CreateDevice) \ @@ -43,6 +43,7 @@ extern struct vk_api g_vk; int vk_loader_open(const char *driver_path, const char *library_name, const char *native_lib_dir); +void vk_loader_close(void); void vk_loader_load_instance(VkInstance instance); void vk_loader_load_device(VkDevice device); PFN_vkGetInstanceProcAddr vk_loader_gipa(void); diff --git a/app/src/main/cpp/waylandcomp/src/vk_present.c b/app/src/main/cpp/waylandcomp/src/vk_present.c index 44fea0c768..aa63253b67 100644 --- a/app/src/main/cpp/waylandcomp/src/vk_present.c +++ b/app/src/main/cpp/waylandcomp/src/vk_present.c @@ -46,6 +46,7 @@ struct vkp_image { static ANativeWindow *g_window; static int g_ahb_import; static char *g_driver_path, *g_library_name, *g_native_lib_dir; +static int g_allow_driver_fallback; static int g_dev_state; static void device_lost(const char *where); static const char *vk_result_name(VkResult r); @@ -250,6 +251,8 @@ void vk_present_set_driver(const char *driver_path, const char *library_name, g_native_lib_dir = native_lib_dir ? strdup(native_lib_dir) : NULL; } +void vk_present_set_driver_fallback(int allow) { g_allow_driver_fallback = allow; } + static void reset_sync(void) { VkSemaphoreCreateInfo semci = {.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO}; for (int k = 0; k < MAX_PRESENTS; k++) { @@ -426,7 +429,7 @@ static void update_map(int scene_w, int scene_h) { else if (align == VKP_ALIGN_PICTURE_RIGHT) g_map.off_x = W - scene_w * g_map.kx; g_map.valid = 1; pthread_mutex_lock(&g_game_picture_lock); - g_game_picture_placed = align == VKP_ALIGN_PICTURE_TOP || align == VKP_ALIGN_PICTURE_BOTTOM || align == VKP_ALIGN_PICTURE_LEFT || align == VKP_ALIGN_PICTURE_RIGHT; + g_game_picture_placed = mode == VKP_MODE_INTEGER || align == VKP_ALIGN_PICTURE_TOP || align == VKP_ALIGN_PICTURE_BOTTOM || align == VKP_ALIGN_PICTURE_LEFT || align == VKP_ALIGN_PICTURE_RIGHT; g_game_picture_rect[0] = g_map.off_x; g_game_picture_rect[1] = g_map.off_y; g_game_picture_rect[2] = g_map.off_x + scene_w * g_map.kx; @@ -549,6 +552,18 @@ static int dev_init(void) { uint32_t npd = 0; g_vk.EnumeratePhysicalDevices(g_inst, &npd, NULL); if (!npd) { + if (g_allow_driver_fallback && g_driver_path && g_library_name) { + LOGE("present: display driver exposed no physical devices; retrying the system Vulkan driver"); + g_vk.DestroyInstance(g_inst, NULL); + g_inst = VK_NULL_HANDLE; + vk_loader_close(); + free(g_driver_path); g_driver_path = NULL; + free(g_library_name); g_library_name = NULL; + g_allow_driver_fallback = 0; + g_colorspace_ext = 0; + g_dev_state = 0; + return dev_init(); + } LOGE("present: no physical devices"); g_dev_state = -1; set_fault("the display driver exposed no GPU to the app"); return -1; diff --git a/app/src/main/cpp/waylandcomp/src/vk_present.h b/app/src/main/cpp/waylandcomp/src/vk_present.h index 2a363979e6..b8cd889219 100644 --- a/app/src/main/cpp/waylandcomp/src/vk_present.h +++ b/app/src/main/cpp/waylandcomp/src/vk_present.h @@ -7,6 +7,7 @@ void vk_present_set_driver(const char *driver_path, const char *library_name, const char *native_lib_dir); +void vk_present_set_driver_fallback(int allow); void vk_present_set_window(ANativeWindow *window); int vkp_apply_window_request(void); diff --git a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c index 25b97ae0f8..2b6aaa1202 100644 --- a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c +++ b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c @@ -24,6 +24,7 @@ extern int droiddeck_wayland_run(void); extern void droiddeck_wayland_set_scale_mode(int mode, int alignment); extern void droiddeck_wayland_send_pointer(int action, int x, int y); extern void droiddeck_wayland_send_touch(int action, int pointer_id, int x, int y); +extern void droiddeck_wayland_send_pen(int flags, int x, int y); extern int droiddeck_cursor_snapshot(int *out, int cap); extern int droiddeck_cursor_serial(void); extern int droiddeck_hud_frame_times(float *out, int len, int64_t *total); @@ -253,12 +254,13 @@ static char *dup_jstr(JNIEnv *env, jstring s) { JNIEXPORT void JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeStartWithSurface( JNIEnv *env, jclass clazz, jobject surface, jstring xdgRuntimeDir, - jstring driverPath, jstring libraryName, jstring nativeLibDir) { + jstring driverPath, jstring libraryName, jstring nativeLibDir, jboolean allowDriverFallback) { set_runtime_dir(env, xdgRuntimeDir); char *dp = dup_jstr(env, driverPath); char *ln = dup_jstr(env, libraryName); char *nl = dup_jstr(env, nativeLibDir); vk_present_set_driver(dp, ln, nl); + vk_present_set_driver_fallback(allowDriverFallback == JNI_TRUE); free(dp); free(ln); free(nl); if (surface) { ANativeWindow *win = ANativeWindow_fromSurface(env, surface); @@ -280,6 +282,12 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSendTouch( droiddeck_wayland_send_touch(action, pointer_id, x, y); } +JNIEXPORT void JNICALL +Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSendPen( + JNIEnv *env, jclass clazz, jint flags, jint x, jint y) { + droiddeck_wayland_send_pen(flags, x, y); +} + JNIEXPORT jint JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeCursorSnapshot( JNIEnv *env, jclass clazz, jintArray out) { @@ -448,6 +456,18 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeGamePictureRect(JNIE return JNI_TRUE; } +JNIEXPORT jboolean JNICALL +Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeOutputSize(JNIEnv *env, jclass clazz, jintArray out) { + (void)clazz; + if (!out || (*env)->GetArrayLength(env, out) < 2) return JNI_FALSE; + int width = 0, height = 0; + vkp_output_size(&width, &height); + if (width <= 0 || height <= 0) return JNI_FALSE; + jint size[2] = {(jint)width, (jint)height}; + (*env)->SetIntArrayRegion(env, out, 0, 2, size); + return JNI_TRUE; +} + JNIEXPORT void JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetUpscaler(JNIEnv *env, jclass clazz, jint mode) { vkp_effects_set_scaling(mode); diff --git a/app/src/main/java/com/droiddeck/launcher/App.kt b/app/src/main/java/com/droiddeck/launcher/App.kt index 564e2f516d..22c89a48d1 100644 --- a/app/src/main/java/com/droiddeck/launcher/App.kt +++ b/app/src/main/java/com/droiddeck/launcher/App.kt @@ -48,7 +48,6 @@ class App : Application() { com.droiddeck.launcher.ui.AgentPet.install(this) if (com.droiddeck.launcher.agent.AgentTab.visible) com.droiddeck.launcher.lab.LabNotice.openOnInstall = "agent" com.droiddeck.launcher.lab.LabNotice.started(this) - com.droiddeck.launcher.core.SteamIntegration.syncShortcutsListing(this) com.droiddeck.launcher.session.QuestExperimental.initialize(this) com.droiddeck.launcher.session.SessionPrefs.applyNtsyncDefault(this) com.droiddeck.launcher.session.SessionPrefs.settleGpuDriverMode(this) @@ -57,6 +56,7 @@ class App : Application() { com.droiddeck.launcher.core.DownloadSource.init(this) prefetchAddonPacks() GpuClockPin.clearLeftover(this) + com.droiddeck.launcher.input.UsbMouse.returnLeftover(this) com.droiddeck.launcher.glasses.Glasses.init(this) com.droiddeck.launcher.glasses.GlassesMenuMirror.initialize(this) BwrapSpawner.start(this) diff --git a/app/src/main/java/com/droiddeck/launcher/DriverMenus.kt b/app/src/main/java/com/droiddeck/launcher/DriverMenus.kt index be0af56a06..689279742f 100644 --- a/app/src/main/java/com/droiddeck/launcher/DriverMenus.kt +++ b/app/src/main/java/com/droiddeck/launcher/DriverMenus.kt @@ -286,7 +286,13 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl // Builds before 0.5.0-nad1 turned the bridge on under Auto without recording it, and // left it on for good (it wins over the pair). Under Auto that switch is taken as Auto's. if (!SessionPrefs.maliFallbackKnown(activity)) - SessionPrefs.setMaliFallbackByAuto(activity, if (SessionPrefs.vkBridge(activity)) "bridge" else "") + SessionPrefs.setMaliFallbackByAuto( + activity, + MaliAutoRoute.initialOwnership( + SessionPrefs.vkBridge(activity), bridgeExplicit(), + SessionPrefs.venus(activity), venusExplicit(), + ), + ) // A lone imported PanVK Android driver set by hand stalls the display the same way // ("black screen with the start-up logo"), so under Auto any imported display goes. val display = SessionPrefs.androidDriver(activity) @@ -356,8 +362,14 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl val pair = pairs.firstOrNull { it.key == key } val row = pairRows.firstOrNull { it.key == key } when { - row?.active == true -> autoStatus = problem?.let { activity.getString(R.string.drivers_up_to_date_check_failed, it) } - ?: activity.getString(R.string.upd_current_status) + row?.active == true -> { + if (MaliAutoRoute.shouldEnd( + SessionPrefs.maliFallbackByAuto(activity), gpu.family.mali, + pair?.key?.let { DriverPairs.isNonAdreno(it) } == true, + )) endMaliFallback() + autoStatus = problem?.let { activity.getString(R.string.drivers_up_to_date_check_failed, it) } + ?: activity.getString(R.string.upd_current_status) + } gpu.family == GpuInfo.Family.POWERVR && (pair == null || !pair.complete) -> { // RADV is not published right now: the Xclipse falls back to the system route. SessionPrefs.ensurePowerVrAutoDrivers(activity) @@ -397,6 +409,12 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl }, "gpu-driver-auto").start() } + private fun bridgeExplicit(): Boolean = + MaliAutoRoute.userChoice(SessionPrefs.vkBridgeExplicit(activity), SessionPrefs.maliFallbackByAuto(activity), MaliAutoRoute.BRIDGE) + + private fun venusExplicit(): Boolean = + MaliAutoRoute.userChoice(SessionPrefs.venusExplicit(activity), SessionPrefs.maliFallbackByAuto(activity), MaliAutoRoute.VENUS) + /** * A Mali with no open driver pair to install ([missing] names the unpublished pair, or null when * no PanVK build covers this GPU) runs through the phone's own driver: Mali (Venus) where this @@ -410,12 +428,21 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl val oldVulkan = com.droiddeck.launcher.session.VenusComponent.hostVulkanTooOld(activity) val venus = oldVulkan == null && com.droiddeck.launcher.session.VenusComponent.available(activity) if (oldVulkan != null) Log.i(TAG, "auto: Mali driver reports Vulkan $oldVulkan; Venus needs 1.2, the bridge stands in") + val ownership = MaliAutoRoute.fallbackOwnership( + venus, + SessionPrefs.vkBridge(activity), bridgeExplicit(), + SessionPrefs.venus(activity), venusExplicit(), + ) if (venus && !SessionPrefs.venus(activity)) { SessionPrefs.setVenus(activity, true) - SessionPrefs.setMaliFallbackByAuto(activity, "venus") + if (SessionPrefs.vkBridge(activity) && !bridgeExplicit()) + SessionPrefs.setVkBridge(activity, false) + SessionPrefs.setMaliFallbackByAuto(activity, ownership) } else if (!venus && !SessionPrefs.vkBridge(activity)) { SessionPrefs.setVkBridge(activity, true) - SessionPrefs.setMaliFallbackByAuto(activity, "bridge") + SessionPrefs.setMaliFallbackByAuto(activity, ownership) + } else if (ownership != MaliAutoRoute.NONE) { + SessionPrefs.setMaliFallbackByAuto(activity, ownership) } val route = activity.getString(if (venus) R.string.drivers_route_venus else R.string.drivers_route_bridge) Log.i(TAG, "auto: Mali stand-in route $route (missing pair: ${missing ?: "none covers ${gpu.name}"})") @@ -503,7 +530,9 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl // A route Auto switched on in place of a missing pair goes off now that one is // here. A Mali bridge or Venus switch the user set stays: it wins for the session // (DeviceSupport.vkBridge, VenusComponent.wanted) and the pair waits. - if (gpu.family.mali && DriverPairs.isNonAdreno(pair.key)) endMaliFallback() + if (MaliAutoRoute.shouldEnd( + SessionPrefs.maliFallbackByAuto(activity), gpu.family.mali, DriverPairs.isNonAdreno(pair.key), + )) endMaliFallback() val restart = displayChanged && CompositorHost.isStarted if (auto) { val trial = AutoDriverTrial.current(activity) @@ -744,4 +773,3 @@ internal fun Context.displayNameOf(uri: Uri): String? = if (uri.scheme == "file" } catch (e: Exception) { null } - diff --git a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt index b195192643..c79f757531 100644 --- a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt @@ -182,6 +182,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet private var paceCores by mutableStateOf(true) private var ramCapMb by mutableStateOf(0) private var zramClient by mutableStateOf(true) + private var zramIdle by mutableStateOf(true) private var vramCapMb by mutableStateOf(0) private var gpuClockPin by mutableStateOf(false) private var prootNoSeccomp by mutableStateOf(false) @@ -366,15 +367,78 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet SteamIntegration.Feature.BRIGHTNESS -> integrationSettings(SteamIntegration.brightnessSettings(this)) SteamIntegration.Feature.HOME -> if (HomeApp.isDefault(this)) HomeApp.openSystemHomeSettings(this) else offerHomeScreen() SteamIntegration.Feature.SHORTCUTS -> { - if (!integrationState.shortcuts) shortcutsTried = true - SteamIntegration.setShortcutsListed(this, true) - integrationSettings(SteamIntegration.shortcutSettings(this), android.provider.Settings.ACTION_ACCESSIBILITY_SETTINGS) + if (integrationState.shortcuts) openShortcutSettings() else installShortcuts() } } } - private fun openAppInfo() = - integrationSettings(Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.parse("package:$packageName"))) + private fun openShortcutSettings() = + integrationSettings(SteamIntegration.shortcutSettings(this), android.provider.Settings.ACTION_ACCESSIBILITY_SETTINGS) + + private fun installShortcuts() { + if (ShortcutsInstall.running) return + ShortcutsInstall.running = true + Thread({ + val result = runCatching { + val apk = SteamIntegration.bundledShortcuts(this) + when { + SteamIntegration.shortcutsInstalled(this, apk) -> { + ShortcutsInstall.running = false + ui.post { shortcutsReady() } + } + !com.droiddeck.launcher.update.SelfInstaller.canInstall(this) -> { + ShortcutsInstall.running = false + ui.post { integrationSettings(com.droiddeck.launcher.update.SelfInstaller.permissionIntent(this)) } + } + else -> com.droiddeck.launcher.update.SelfInstaller.install(this, apk, com.droiddeck.shortcuts.Relay.PACKAGE, + SteamIntegration.SHORTCUTS_STATUS) { id -> ShortcutsInstall.session = id } + } + } + result.onFailure { e -> + ShortcutsInstall.running = false + ui.post { shortcutsFailed(e.message) } + } + }, "shortcuts-install").start() + } + + private fun shortcutsReady() { + shortcutsTried = true + Thread({ + val deadline = android.os.SystemClock.uptimeMillis() + 3000 + while (!SteamIntegration.shortcutsListed(this) && android.os.SystemClock.uptimeMillis() < deadline) Thread.sleep(100) + ui.post { openShortcutSettings() } + }, "shortcuts-listed").start() + } + + private fun shortcutsFailed(message: String?) { + android.widget.Toast.makeText(this, message?.let { getString(R.string.integration_shortcuts_install_failed_with, it) } + ?: getString(R.string.integration_shortcuts_install_failed), android.widget.Toast.LENGTH_LONG).show() + } + + private val shortcutsInstallStatus = object : android.content.BroadcastReceiver() { + override fun onReceive(context: android.content.Context, intent: Intent) { + val session = intent.getIntExtra(android.content.pm.PackageInstaller.EXTRA_SESSION_ID, -1) + if (session < 0 || session != ShortcutsInstall.session) return + val status = intent.getIntExtra(android.content.pm.PackageInstaller.EXTRA_STATUS, + android.content.pm.PackageInstaller.STATUS_FAILURE) + if (status != android.content.pm.PackageInstaller.STATUS_PENDING_USER_ACTION) { + ShortcutsInstall.session = -1 + ShortcutsInstall.running = false + } + when (status) { + android.content.pm.PackageInstaller.STATUS_PENDING_USER_ACTION -> { + val confirm = if (android.os.Build.VERSION.SDK_INT >= 33) intent.getParcelableExtra(Intent.EXTRA_INTENT, Intent::class.java) + else @Suppress("DEPRECATION") intent.getParcelableExtra(Intent.EXTRA_INTENT) + val safe = confirm?.let { com.droiddeck.launcher.update.SelfInstaller.safeConfirmIntent(this@FrontEndActivity, it) } + if (safe == null || runCatching { startActivity(safe) }.isFailure) shortcutsFailed(null) + } + android.content.pm.PackageInstaller.STATUS_SUCCESS -> shortcutsReady() + else -> shortcutsFailed(intent.getStringExtra(android.content.pm.PackageInstaller.EXTRA_STATUS_MESSAGE)) + } + } + } + + private fun openAppInfo() = integrationSettings(SteamIntegration.shortcutsAppInfo()) private fun openWifiDiscoverySettings() { if (!WifiDiscovery.permissionGranted(this)) { @@ -535,6 +599,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet private var upscaleSharpness by mutableStateOf(75) private var hdrReason by mutableStateOf(null) private var touchMode by mutableStateOf(SessionPrefs.TOUCH_AUTO) + private var pen by mutableStateOf(null) private var suspendPolicy by mutableStateOf(SessionPrefs.SUSPEND_MANUAL) private var steamDownloadsInBackground by mutableStateOf(false) private var oscMode by mutableStateOf(SessionPrefs.OSC_AUTO) @@ -1138,6 +1203,9 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet homeChoiceOpen = savedInstanceState?.getBoolean(STATE_HOME_CHOICE_OPEN) == true gameSpaceOffered = savedInstanceState?.getBoolean(STATE_GAME_SPACE_OFFERED) == true if (savedInstanceState == null) readIntegrationIntent(intent) + val shortcutsFilter = android.content.IntentFilter(SteamIntegration.SHORTCUTS_STATUS) + if (android.os.Build.VERSION.SDK_INT >= 33) registerReceiver(shortcutsInstallStatus, shortcutsFilter, RECEIVER_NOT_EXPORTED) + else registerReceiver(shortcutsInstallStatus, shortcutsFilter) readGameIntent(intent) // A Lab build is usually the agent's work, so the app comes back where the agent is. if (savedInstanceState == null && navRequest == null && com.droiddeck.launcher.lab.LabOverlay.promoted && com.droiddeck.launcher.agent.AgentTab.visible) navRequest = "agent" @@ -1974,7 +2042,6 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet launcherOrientation = com.droiddeck.launcher.core.AppUiPrefs.orientation(this) requestedOrientation = launcherOrientation homePage = com.droiddeck.launcher.core.AppUiPrefs.homePage(this) - SteamIntegration.syncShortcutsListing(this) refreshWifiDiscovery() com.droiddeck.launcher.stores.StoresState.refresh(this) com.droiddeck.launcher.stores.StoresState.libraryListener = { refreshAddedGames(); refresh() } @@ -2083,6 +2150,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet gameLaunchRequest.incrementAndGet() cancelCompatLaunch() updates.unregister() + runCatching { unregisterReceiver(shortcutsInstallStatus) } super.onDestroy() } @@ -2471,6 +2539,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet upscaler = upscaler, upscaleSharpness = upscaleSharpness, gpuDrivers = drivers.summary(), touchMode = touchMode, + pen = pen, suspendPolicy = suspendPolicy, steamDownloadsInBackground = steamDownloadsInBackground, pipSupported = com.droiddeck.launcher.session.SessionPipController.supported(this), @@ -2523,6 +2592,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet onUpscaler = { m -> SessionPrefs.setUpscaler(this, m); upscaler = m }, onUpscaleSharpness = { pct -> SessionPrefs.setUpscaleSharpness(this, pct); upscaleSharpness = pct }, onTouch = { t -> SessionPrefs.setTouchMode(this, t); touchMode = t }, + onPen = { key, value -> SessionPrefs.setPenSetting(this, key, value); pen = SessionPrefs.pen(this) }, onSuspendPolicy = { policy -> SessionPrefs.setSuspendPolicy(this, mode, policy); suspendPolicy = policy }, onSteamDownloadsInBackground = { enabled -> SessionPrefs.setSteamDownloadsInBackground(this, enabled) @@ -2632,7 +2702,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet fsyncFirst = fsyncFirst, gamescopeRealtime = gamescopeRealtime, gpuClockPin = gpuClockPin, - ramCapMb = ramCapMb, vramCapMb = vramCapMb, zramClient = zramClient, + ramCapMb = ramCapMb, vramCapMb = vramCapMb, zramClient = zramClient, zramIdle = zramIdle, deviceRamMb = (android.app.ActivityManager.MemoryInfo() .also((getSystemService(ACTIVITY_SERVICE) as android.app.ActivityManager)::getMemoryInfo).totalMem / (1024 * 1024)).toInt(), ramCapAvailable = com.droiddeck.launcher.core.ZramSupport.supported(), @@ -2652,6 +2722,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet onGpuClockPin = { on -> SessionPrefs.setGpuClockPin(this, on); gpuClockPin = on }, onRamCapMb = { mb -> SessionPrefs.setRamCapMb(this, mb); ramCapMb = mb }, onZramClient = { on -> SessionPrefs.setZramClient(this, on); zramClient = on }, + onZramIdle = { on -> SessionPrefs.setZramIdle(this, on); zramIdle = on }, onVramCapMb = { mb -> SessionPrefs.setVramCapMb(this, mb); vramCapMb = mb }, onProotNoSeccomp = { on -> SessionPrefs.setProotNoSeccomp(this, on); prootNoSeccomp = on }, onProotFastPath = { on -> SessionPrefs.setProotFastPath(this, on); prootFastPath = on }, @@ -2869,6 +2940,8 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet upscaleSharpness = SessionPrefs.upscaleSharpness(this) hdrReason = com.droiddeck.launcher.wayland.HdrSupport.probe(this).reason touchMode = SessionPrefs.touchMode(this) + if (!SessionPrefs.penSeen(this) && com.droiddeck.launcher.input.PenStream.penConnected()) SessionPrefs.setPenSeen(this) + pen = SessionPrefs.pen(this).takeIf { SessionPrefs.penSeen(this) } suspendPolicy = SessionPrefs.suspendPolicy(this, mode) steamDownloadsInBackground = SessionPrefs.steamDownloadsInBackground(this) oscMode = SessionPrefs.oscMode(this) @@ -2949,6 +3022,7 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet paceCores = SessionPrefs.paceCores(this) ramCapMb = SessionPrefs.ramCapMb(this) zramClient = SessionPrefs.zramClient(this) + zramIdle = SessionPrefs.zramIdle(this) vramCapMb = SessionPrefs.vramCapMb(this) gpuClockPin = SessionPrefs.gpuClockPin(this) prootNoSeccomp = SessionPrefs.prootNoSeccomp(this) @@ -3300,3 +3374,9 @@ class FrontEndActivity : ComponentActivity(), com.droiddeck.launcher.ui.AgentPet private val WCP_EXT = listOf("wcp") } } + +// The install session outlives the activity when Android recreates it mid-install. +private object ShortcutsInstall { + @Volatile var session = -1 + @Volatile var running = false +} diff --git a/app/src/main/java/com/droiddeck/launcher/MaliAutoRoute.kt b/app/src/main/java/com/droiddeck/launcher/MaliAutoRoute.kt new file mode 100644 index 0000000000..f4ebf2f0f7 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/MaliAutoRoute.kt @@ -0,0 +1,31 @@ +package com.droiddeck.launcher + +internal object MaliAutoRoute { + const val NONE = "" + const val BRIDGE = "bridge" + const val VENUS = "venus" + + fun initialOwnership(bridgeOn: Boolean, bridgeExplicit: Boolean, venusOn: Boolean, venusExplicit: Boolean): String = + when { + venusOn && !venusExplicit -> VENUS + bridgeOn && !bridgeExplicit -> BRIDGE + else -> NONE + } + + fun fallbackOwnership( + venusAvailable: Boolean, + bridgeOn: Boolean, + bridgeExplicit: Boolean, + venusOn: Boolean, + venusExplicit: Boolean, + ): String = if (venusAvailable) { + if (!venusOn || !venusExplicit) VENUS else NONE + } else { + if (!bridgeOn || !bridgeExplicit) BRIDGE else NONE + } + + fun userChoice(keyStored: Boolean, owner: String, route: String): Boolean = keyStored && owner != route + + fun shouldEnd(ownsRoute: String, mali: Boolean, installedPair: Boolean): Boolean = + mali && installedPair && ownsRoute != NONE +} diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index d3e8cf877c..b28607f7d8 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -97,8 +97,11 @@ import com.droiddeck.launcher.input.PadState import com.droiddeck.launcher.input.SteamControllerBle import com.droiddeck.launcher.input.DirectTouchHold import com.droiddeck.launcher.input.GestureTouchStreamGate +import com.droiddeck.launcher.input.PenRouter +import com.droiddeck.launcher.input.PenStream import com.droiddeck.launcher.input.PointerGestures import com.droiddeck.launcher.input.PointerSpace +import com.droiddeck.launcher.input.pointerSubset import com.droiddeck.launcher.input.SecondScreenDisplay import com.droiddeck.launcher.input.SecondScreenDisplays import com.droiddeck.launcher.input.SecondScreenMode @@ -151,6 +154,9 @@ import com.droiddeck.launcher.ui.sessionDrawerPages import com.droiddeck.launcher.ui.step import kotlin.math.abs +private const val SCREEN_EFFECTS_TARGET_AUTO = "auto" +private const val SCREEN_EFFECTS_TARGET_GLOBAL = "global" + class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droiddeck.launcher.ui.AgentPetHost { override fun attachBaseContext(newBase: android.content.Context) { super.attachBaseContext(newBase) @@ -263,6 +269,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private var steamTouchOptions: com.droiddeck.launcher.input.SteamTouchConfig.Options? = null private var routedTouchMode = SessionPrefs.TOUCH_AUTO private var touchRoute: com.droiddeck.launcher.input.TouchRouter.Route? = null + private var penSettings by mutableStateOf(SessionPrefs.Pen()) + private var penSeen by mutableStateOf(false) + private var penRoute: PenRouter.Route? = null + private var penDown = false + private val penStream = PenStream(WaylandCompositor::nativeSendPen) private var keyboard: KeyboardHost? = null private var desktopKeyboardButton: com.droiddeck.launcher.input.DesktopKeyboardButton? = null private var lastUserPressMs = 0L @@ -396,6 +407,38 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde mouseAttached = ::externalMouseAttached, ) private var lastExternalMouse: InputDevice? = null + private val usbMenuHold = com.droiddeck.launcher.input.MouseMenuHold( + schedule = { runnable, ms -> uiHandler.postDelayed(runnable, ms) }, + cancel = { uiHandler.removeCallbacks(it) }, + onMenu = { releasePads(); drawerOpen = true }, + ) + private val usbMouse = com.droiddeck.launcher.input.UsbMouse(this, object : com.droiddeck.launcher.input.UsbMouse.Listener { + override fun onMove(dx: Int, dy: Int) { + usbMenuHold.onMove(dx, dy) + onRelativeMouse(dx.toFloat(), dy.toFloat()) + } + override fun onButton(index: Int, down: Boolean) { + if (down) lastUserPressMs = android.os.SystemClock.uptimeMillis() + heldButtons.set(8, USB_MOUSE_BUTTONS[index], down) + usbMenuHold.onButton(index, down) + } + override fun onWheel(steps: Int) = sendSceneWheel(-steps) + override fun onChanged() = updatePointerCapture() + override fun onLost() { + usbMenuHold.reset() + heldButtons.release(8) + updatePointerCapture() + requestRelativeMouse() + } + }) + private var pointerCaptureRefused = false + // Android grants capture on the focused display, which the phone's own screen is; only sessions shown on + // another display, like REDMAGIC's cast-mode virtual display, are refused, so only they ask for the USB mouse. + private val usbMouseFallback = Runnable { + if (window.decorView.hasPointerCapture() || window.decorView.display?.displayId == android.view.Display.DEFAULT_DISPLAY) return@Runnable + pointerCaptureRefused = true + if (usbMouse.grab()) Log.i(TAG, "pointer capture refused; reading the USB mouse directly") + } private var drawerDirectionKey = KeyEvent.KEYCODE_UNKNOWN private var drawerDirectionDownTime = 0L private var drawerDirectionDeviceId = -1 @@ -503,6 +546,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private var upscaler by mutableStateOf(0) private var upscaleSharpness by mutableStateOf(75) private var effects by mutableStateOf(ScreenEffects.OFF) + private var observedScreenEffectsProfileId by mutableStateOf(null) + private var screenEffectsTarget by mutableStateOf(SCREEN_EFFECTS_TARGET_AUTO) private var cardboard by mutableStateOf(Cardboard.OFF) private var headTracker: HeadTracker? = null private var steamVrStatus by mutableStateOf(null) @@ -545,6 +590,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private val cardboardPrefListener = android.content.SharedPreferences.OnSharedPreferenceChangeListener { _, key -> if (key == SessionPrefs.CARDBOARD_KEY) uiHandler.post { applyCardboard(SessionPrefs.cardboard(this)) } } + private val screenEffectsProfilePrefListener = android.content.SharedPreferences.OnSharedPreferenceChangeListener { _, key -> + if (key == SessionPrefs.SCREEN_EFFECTS_ACTIVE_PROFILE_KEY) uiHandler.post { + syncActiveScreenEffectsProfile() + } + } private val shortcutPrefListener = android.content.SharedPreferences.OnSharedPreferenceChangeListener { _, key -> if (key == null || key == PhysicalShortcuts.KEY) { physicalShortcuts.bindings = PhysicalShortcuts.read(this) @@ -657,6 +707,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private val deviceListener = object : InputManager.InputDeviceListener { override fun onInputDeviceAdded(deviceId: Int) { logInputDevice("connected", deviceId) + if (!penSeen && InputDevice.getDevice(deviceId)?.let { PenStream.isPenDevice(it.sources) } == true) notePenSeen() joyConVr?.refresh() padBridge?.syncConnectedControllers() refreshControls() @@ -667,6 +718,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } override fun onInputDeviceRemoved(deviceId: Int) { physicalShortcuts.onDeviceRemoved(deviceId) + penStream.deviceRemoved(deviceId) Log.i(TAG, "input device $deviceId disconnected") dropMouseCursor() backQamInput.onDeviceRemoved(deviceId) @@ -756,11 +808,17 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde override fun dispatchPointerCaptureChanged(hasCapture: Boolean) { super.dispatchPointerCaptureChanged(hasCapture) Log.i(TAG, "pointer capture " + if (hasCapture) "on" else "off") - if (!hasCapture) { + if (hasCapture) { + pointerCaptureRefused = false + if (usbMouse.active) updatePointerCapture() + } else { releaseHeldGuestInput() uiHandler.postDelayed(::updatePointerCapture, 250) } } + override fun onResolvePointerIcon(event: MotionEvent, pointerIndex: Int): android.view.PointerIcon? = + if (platformPointerShown == false && PenStream.isPen(event, pointerIndex)) pointerIcon + else super.onResolvePointerIcon(event, pointerIndex) } sessionRoot = root surfaceView = SurfaceView(this) @@ -842,7 +900,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde refreshGestureConfig() root.isMotionEventSplittingEnabled = true surfaceView.setOnTouchListener { _, event -> - if (!event.isFromSource(InputDevice.SOURCE_TOUCHSCREEN)) { + if (!event.isFromSource(InputDevice.SOURCE_TOUCHSCREEN) && PenStream.penIndex(event) < 0) { false } else if (!gestureTouchStreamGate.accepts(GestureTouchStreamGate.Source.SURFACE, event)) { false @@ -977,6 +1035,18 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde isFocusableInTouchMode = true defaultFocusHighlightEnabled = false setContent { + val activeEffectsProfileId = currentScreenEffectsProfileId() + val effectsEditorTarget = if (drawerOpen) screenEffectsTarget else null + val effectsEditorProfileId = activeEffectsProfileId.takeIf { + effectsEditorTarget == SCREEN_EFFECTS_TARGET_AUTO + } + androidx.compose.runtime.LaunchedEffect(effectsEditorTarget, effectsEditorProfileId) { + when (effectsEditorTarget) { + SCREEN_EFFECTS_TARGET_AUTO -> syncActiveScreenEffectsProfile() + null -> Unit + else -> syncScreenEffectsTarget(effectsEditorTarget) + } + } val uiPointer = appUiOwnsPointer() androidx.compose.runtime.SideEffect { com.droiddeck.launcher.glasses.GlassesMenuMirror.setSessionMenuVisible(this@SessionActivity, @@ -986,7 +1056,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde androidx.compose.runtime.DisposableEffect(Unit) { onDispose { com.droiddeck.launcher.glasses.GlassesMenuMirror.setSessionMenuVisible(this@SessionActivity, false) } } - androidx.compose.runtime.LaunchedEffect(drawerOpen, pcKeyboardOpen, achievementsOpen, inputSettingsOpen, pipUi, bottomOutputActive) { updatePointerCapture() } + androidx.compose.runtime.LaunchedEffect(drawerOpen, pcKeyboardOpen, achievementsOpen, inputSettingsOpen, pipUi, bottomOutputActive, wowChatOnTop) { updatePointerCapture() } androidx.compose.runtime.LaunchedEffect(bottomOutputActive) { hud.setHidden(pipUi || bottomOutputActive) } androidx.compose.runtime.LaunchedEffect(pipUi) { hud.setHidden(pipUi || bottomOutputActive) @@ -1070,6 +1140,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde }, ) LaunchedEffect(AgentGuest.focusRevision, secondScreenDisplays.isNotEmpty(), drawerGameInventoryRevision) { + val startingActiveEffectsProfileId = + SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity) val nextGame = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) { if (SessionState.mode == SessionService.MODE_RUN) SessionState.program?.let { "program:$it" } else { @@ -1092,18 +1164,36 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde val id = AgentGuest.activeSteamAppId( this@SessionActivity, cachedIds + inventoryIds ) - val name = id?.let { activeId -> - games.firstOrNull { it.profileKey == activeId.toString() }?.name + val activeGame = id?.let { activeId -> + games.firstOrNull { it.profileKey == activeId.toString() } } - id to name + id to activeGame } if (target.first != frameGenActiveGameId) { + val previousActiveGameId = frameGenActiveGameId frameGenActiveGameId = target.first + if ((target.first != null || previousActiveGameId != null) && + SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity) == + startingActiveEffectsProfileId + ) { + val activeEffectsProfileId = target.first?.let { + SessionPrefs.screenEffectsProfileId( + SessionService.MODE_STEAM, + target.second?.gameIdString ?: it.toString(), + null, + ) + } + SessionPrefs.setActiveScreenEffectsProfile( + this@SessionActivity, activeEffectsProfileId, + ) + observedScreenEffectsProfileId = activeEffectsProfileId + syncActiveScreenEffectsProfile() + } if (drawerGameProfileFollowState.followsSteam) { loadFrameGenFor(target.first) } } - frameGenActiveGameName = target.second + frameGenActiveGameName = target.second?.name } if (nextGame != gestureGame) { if (nextGame != null) gameStarts++ @@ -1218,7 +1308,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde onAndroidKeyboard = { pcKeyboardOpen = false; keyboard?.toggle() }, onClose = { pcKeyboardOpen = false }, ) - if (!drawerDocked) SessionMenu(docked = false) + if (!drawerDocked) SessionMenu( + docked = false, + effectsEditorProfileId = effectsEditorProfileId, + effectsEditorTarget = effectsEditorTarget, + ) LaunchedEffect(achievementsOpen) { if (achievementsOpen) { releasePads() @@ -1268,7 +1362,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } @androidx.compose.runtime.Composable - private fun SessionMenu(docked: Boolean) { + private fun SessionMenu( + docked: Boolean, + effectsEditorProfileId: String?, + effectsEditorTarget: String?, + ) { SessionDrawer(drawerOpen || (docked && drawerPinned), drawerPage, drawerControllerActive, onPageChange = { drawerPage = it }, docked = docked, backRequest = drawerBackRequests, onLayerChange = { drawerLayerOpen = it }, a = DrawerActions( steam = SessionState.mode == SessionService.MODE_STEAM, @@ -1284,6 +1382,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde hudConfig = hudConfig, upscaler = upscaler, upscaleSharpness = upscaleSharpness, effects = effects, + screenEffectsTarget = screenEffectsTarget, + screenEffectsTargets = screenEffectsTargetOptions(), + screenEffectsCanDelete = screenEffectsProfileIdForTarget(screenEffectsTarget)?.let { + SessionPrefs.hasScreenEffectsOverride(this@SessionActivity, it) + } == true, cardboard = cardboard, cardboardSensor = hasRotationSensor, onCardboard = { c -> SessionPrefs.setCardboard(this@SessionActivity, c); applyCardboard(c) }, @@ -1319,6 +1422,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde micEnabled = SessionState.micEnabled, onMicEnabled = { SessionService.setMicEnabled(this@SessionActivity, it) }, touchAuto = getString(if (usingTouchpad()) R.string.session_touch_auto_touchpad else R.string.session_touch_auto_direct), + pen = penSettings.takeIf { penSeen }, + onPen = { key, value -> SessionPrefs.setPenSetting(this@SessionActivity, key, value); readPrefs() }, fexPreset = fexPreset, secondScreenMode = secondScreenMode, secondScreenNone = !bottomOutputActive && !dockDrawer(), @@ -1336,17 +1441,127 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde onHudOrderReset = { hudConfig = DroidDeckHudConfig.clearOrder(this@SessionActivity); hud.applyConfig() }, onHudExport = { exportHudDiagnostics() }, onUpscaler = { m -> - SessionPrefs.setUpscaler(this@SessionActivity, m); upscaler = m - WaylandCompositor.nativeSetUpscaler(m) - WaylandCompositor.nativeSetLookName(ScreenEffectLooks.match(effects, m)?.name) + val target = effectsEditorTarget ?: screenEffectsTarget + val activeProfileId = + SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity) + + if (target == SCREEN_EFFECTS_TARGET_AUTO && + activeProfileId != effectsEditorProfileId) { + Log.w(TAG, "Screen effects profile changed while editing; discarding stale upscaler edit") + observedScreenEffectsProfileId = activeProfileId + val activeEffects = SessionPrefs.screenEffects(this@SessionActivity, activeProfileId) + val activeUpscaler = SessionPrefs.screenEffectsUpscaler(this@SessionActivity, activeProfileId) + effects = activeEffects + upscaler = activeUpscaler + activeEffects.push(activeUpscaler) + } else { + val profileId = screenEffectsProfileIdForTarget(target) + SessionPrefs.setScreenEffectsUpscaler(this@SessionActivity, profileId, m) + + if (target == screenEffectsTarget) { + upscaler = m + if (screenEffectsUpscalerTargetAppliesToLiveOutput(target)) { + val liveProfileId = + SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity) + val liveUpscaler = + SessionPrefs.screenEffectsUpscaler(this@SessionActivity, liveProfileId) + val liveEffects = + SessionPrefs.screenEffects(this@SessionActivity, liveProfileId) + WaylandCompositor.nativeSetUpscaler(liveUpscaler) + WaylandCompositor.nativeSetLookName( + ScreenEffectLooks.match(liveEffects, liveUpscaler)?.name + ) + liveEffects.push(liveUpscaler) + } + } + } + }, + onPresetUpscaler = { m -> + val target = effectsEditorTarget ?: screenEffectsTarget + val activeProfileId = if (target == SCREEN_EFFECTS_TARGET_AUTO) { + SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity) + } else null + + if (target == SCREEN_EFFECTS_TARGET_AUTO && + activeProfileId != effectsEditorProfileId) { + Log.w(TAG, "Screen effects profile changed while editing; discarding stale upscaler edit") + observedScreenEffectsProfileId = activeProfileId + val activeEffects = SessionPrefs.screenEffects(this@SessionActivity, activeProfileId) + effects = activeEffects + activeEffects.push(upscaler) + } else { + val profileId = screenEffectsProfileIdForTarget(target) + SessionPrefs.setScreenEffectsUpscaler(this@SessionActivity, profileId, m) + if (target == screenEffectsTarget) { + upscaler = m + if (screenEffectsUpscalerTargetAppliesToLiveOutput(target)) { + val liveProfileId = + SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity) + val liveUpscaler = + SessionPrefs.screenEffectsUpscaler(this@SessionActivity, liveProfileId) + val liveEffects = + SessionPrefs.screenEffects(this@SessionActivity, liveProfileId) + WaylandCompositor.nativeSetUpscaler(liveUpscaler) + WaylandCompositor.nativeSetLookName( + ScreenEffectLooks.match(liveEffects, liveUpscaler)?.name + ) + liveEffects.push(liveUpscaler) + } + } + } }, onUpscaleSharpness = { pct -> SessionPrefs.setUpscaleSharpness(this@SessionActivity, pct); upscaleSharpness = pct WaylandCompositor.nativeSetUpscaleSharpness(pct) }, onEffects = { e -> - SessionPrefs.setScreenEffects(this@SessionActivity, e); effects = e - e.push(upscaler) + if (drawerOpen || (docked && drawerPinned)) { + val editorTarget = effectsEditorTarget ?: screenEffectsTarget + if (editorTarget != screenEffectsTarget) { + syncScreenEffectsTarget(screenEffectsTarget) + } else if (editorTarget == SCREEN_EFFECTS_TARGET_AUTO) { + val activeProfileId = + SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity) + if (activeProfileId != effectsEditorProfileId) { + Log.w(TAG, "Screen effects profile changed while editing; discarding stale edit") + observedScreenEffectsProfileId = activeProfileId + val activeEffects = SessionPrefs.screenEffects(this@SessionActivity, activeProfileId) + effects = activeEffects + activeEffects.push(upscaler) + } else { + SessionPrefs.setScreenEffects(this@SessionActivity, activeProfileId, e) + observedScreenEffectsProfileId = activeProfileId + effects = e + e.push(upscaler) + } + } else { + val profileId = screenEffectsProfileIdForTarget(editorTarget) + SessionPrefs.setScreenEffects(this@SessionActivity, profileId, e) + effects = e + if (screenEffectsTargetAppliesToLiveOutput(editorTarget)) e.push(upscaler) + } + } + }, + onScreenEffectsTarget = ::selectScreenEffectsTarget, + onScreenEffectsReset = { + val target = effectsEditorTarget ?: screenEffectsTarget + val profileStillMatches = target != SCREEN_EFFECTS_TARGET_AUTO || + SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity) == effectsEditorProfileId + if (target == screenEffectsTarget && profileStillMatches) { + resetScreenEffectsTarget(target) + } + }, + onScreenEffectsDelete = { + val target = effectsEditorTarget ?: screenEffectsTarget + val profileStillMatches = target != SCREEN_EFFECTS_TARGET_AUTO || + SessionPrefs.activeScreenEffectsProfileId(this@SessionActivity) == effectsEditorProfileId + if (target == screenEffectsTarget && profileStillMatches) { + deleteScreenEffectsTarget(target) + } + }, + onScreenEffectsProfilesRefresh = { + drawerGameInventoryRevision++ + refreshDrawerGameProfile() }, onTextureAnisotropy = { value -> drawerGameProfileId?.let { appId -> @@ -1969,6 +2184,131 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde }, "drawer-game-no-steam").start() } + private fun syncActiveScreenEffectsProfile() { + val profileId = SessionPrefs.activeScreenEffectsProfileId(this) + observedScreenEffectsProfileId = profileId + val activeEffects = SessionPrefs.screenEffects(this, profileId) + val activeUpscaler = SessionPrefs.screenEffectsUpscaler(this, profileId) + if (screenEffectsTarget == SCREEN_EFFECTS_TARGET_AUTO) { + effects = activeEffects + upscaler = activeUpscaler + } + WaylandCompositor.nativeSetUpscaler(activeUpscaler) + activeEffects.push(activeUpscaler) + } + + private fun screenEffectsProfileIdForTarget(target: String): String? = when (target) { + SCREEN_EFFECTS_TARGET_AUTO -> currentScreenEffectsProfileId() + SCREEN_EFFECTS_TARGET_GLOBAL -> null + else -> target + } + + private fun screenEffectsTargetOptions(): List> { + val installed = LibraryCache.load(this) + .associate { it.gameIdString to it.name } + val ids = linkedSetOf() + ids.addAll(installed.keys) + SessionPrefs.screenEffectsProfileIds(this).forEach { saved -> + if (saved.startsWith("game:")) { + saved.removePrefix("game:").toULongOrNull()?.let { ids.add(it.toString()) } + } + } + currentScreenEffectsProfileId()?.takeIf { it.startsWith("game:") } + ?.removePrefix("game:")?.toULongOrNull()?.let { ids.add(it.toString()) } + + return buildList { + add(SCREEN_EFFECTS_TARGET_AUTO to getString(R.string.screen_effects_target_auto)) + add(SCREEN_EFFECTS_TARGET_GLOBAL to getString(R.string.frame_gen_scope_global)) + ids.sortedBy { installed[it]?.lowercase() ?: it }.forEach { id -> + add("game:$id" to (installed[id] ?: getString(R.string.game_env_profile, id))) + } + } + } + + private fun screenEffectsUpscalerTargetAppliesToLiveOutput(target: String): Boolean { + if (target == SCREEN_EFFECTS_TARGET_AUTO) return true + val selectedProfileId = screenEffectsProfileIdForTarget(target) + val activeProfileId = currentScreenEffectsProfileId() + if (selectedProfileId == activeProfileId) return true + return selectedProfileId == null && + (activeProfileId == null || + !SessionPrefs.hasScreenEffectsUpscalerOverride(this, activeProfileId)) + } + + private fun screenEffectsTargetAppliesToLiveOutput(target: String): Boolean { + if (target == SCREEN_EFFECTS_TARGET_AUTO) return true + val selectedProfileId = screenEffectsProfileIdForTarget(target) + val activeProfileId = currentScreenEffectsProfileId() + if (selectedProfileId == activeProfileId) return true + return selectedProfileId == null && + (activeProfileId == null || !SessionPrefs.hasScreenEffectsOverride(this, activeProfileId)) + } + + private fun syncScreenEffectsTarget(target: String) { + if (target == SCREEN_EFFECTS_TARGET_AUTO) { + syncActiveScreenEffectsProfile() + return + } + val profileId = screenEffectsProfileIdForTarget(target) + val targetEffects = SessionPrefs.screenEffects(this, profileId) + val targetUpscaler = SessionPrefs.screenEffectsUpscaler(this, profileId) + effects = targetEffects + upscaler = targetUpscaler + if (screenEffectsTargetAppliesToLiveOutput(target)) { + WaylandCompositor.nativeSetUpscaler(targetUpscaler) + WaylandCompositor.nativeSetLookName(ScreenEffectLooks.match(targetEffects, targetUpscaler)?.name) + targetEffects.push(targetUpscaler) + } + } + + private fun selectScreenEffectsTarget(target: String) { + if (target == screenEffectsTarget) return + screenEffectsTarget = target + syncScreenEffectsTarget(target) + } + + private fun resetScreenEffectsTarget(target: String) { + if (target != screenEffectsTarget) return + SessionPrefs.resetScreenEffectsProfile(this, screenEffectsProfileIdForTarget(target)) + syncScreenEffectsTarget(target) + } + + private fun deleteScreenEffectsTarget(target: String) { + if (target != screenEffectsTarget) return + val profileId = screenEffectsProfileIdForTarget(target) ?: return + SessionPrefs.deleteScreenEffectsProfile(this, profileId) + syncScreenEffectsTarget(target) + } + + private fun currentScreenEffectsProfileId(): String? { + if (SessionState.running) { + return observedScreenEffectsProfileId + ?: SessionPrefs.activeScreenEffectsProfileId(this) + } + val mode = intent.getStringExtra(SessionService.EXTRA_MODE) ?: SessionService.MODE_STEAM + val explicitGameId = intent.getStringExtra(SessionService.EXTRA_GAME_ID) + ?.trim() + ?.takeIf(com.droiddeck.launcher.frontend.GameLaunchLink::validId) + val steamUrlGameId = intent.getStringExtra(SessionService.EXTRA_STEAM_URL) + ?.let { url -> + when { + url.startsWith("steam://rungameid/") -> + url.removePrefix("steam://rungameid/") + url.startsWith("steam://run/") -> + url.removePrefix("steam://run/") + else -> null + } + } + ?.takeIf(com.droiddeck.launcher.frontend.GameLaunchLink::validId) + val gameId = explicitGameId ?: steamUrlGameId + + return SessionPrefs.screenEffectsProfileId( + mode, + gameId, + intent.getStringExtra(SessionService.EXTRA_PROGRAM), + ) + } + private fun loadingMode(): String = if (SessionState.running) SessionState.mode else intent.getStringExtra(SessionService.EXTRA_MODE) ?: SessionService.MODE_STEAM @@ -2063,9 +2403,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde hudConfig = DroidDeckHudConfig.load(this) hudColor = SessionPrefs.hudColor(this) hudOpacity = SessionPrefs.hudOpacity(this) - upscaler = SessionPrefs.upscaler(this) + upscaler = SessionPrefs.screenEffectsUpscaler(this, screenEffectsProfileIdForTarget(screenEffectsTarget)) upscaleSharpness = SessionPrefs.upscaleSharpness(this) - effects = SessionPrefs.screenEffects(this) + effects = SessionPrefs.screenEffects(this, screenEffectsProfileIdForTarget(screenEffectsTarget)) applyCardboard(SessionPrefs.cardboard(this)) if (SessionPrefs.cardboardSourceBeforeSteamVr(this) >= 0 && !steamVrSwitchedPicture) { steamVrSwitchedPicture = true @@ -2075,6 +2415,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde textureLodBias = SessionPrefs.textureLodBias(this) val nextTouchMode = SessionPrefs.touchMode(this) if (touchMode != nextTouchMode) { + cancelPen() if (::touchpad.isInitialized) touchpad.cancel() if (::directTouchHold.isInitialized) directTouchHold.cancel() if (::twoFingerGestures.isInitialized) twoFingerGestures.cancel() @@ -2088,6 +2429,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (nextTouchMode == SessionPrefs.TOUCH_OFF || !usingTouchpad()) cursorVisible = false } touchMode = nextTouchMode + val nextPen = SessionPrefs.pen(this) + if (penSettings != nextPen) cancelPen() + penSettings = nextPen + penStream.sideButton = nextPen.button + if (!penSeen && (SessionPrefs.penSeen(this) || PenStream.penConnected())) notePenSeen() val nextRoutedTouchMode = effectiveTouchMode() if (routedTouchMode != nextRoutedTouchMode) gestureTouchStreamGate.reset() routedTouchMode = nextRoutedTouchMode @@ -2306,9 +2652,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde .onFailure { Log.e(TAG, "Could not update game environment", it) } }, "game-env-publish").start() WaylandCompositor.nativeSetScaleMode(SCALE_FIT, ALIGN_CENTER) - WaylandCompositor.nativeSetUpscaler(SessionPrefs.upscaler(this)) + val activeProfileId = currentScreenEffectsProfileId() + val activeUpscaler = SessionPrefs.screenEffectsUpscaler(this, activeProfileId) + val activeEffects = SessionPrefs.screenEffects(this, activeProfileId) + WaylandCompositor.nativeSetUpscaler(activeUpscaler) WaylandCompositor.nativeSetUpscaleSharpness(SessionPrefs.upscaleSharpness(this)) - SessionPrefs.screenEffects(this).push(SessionPrefs.upscaler(this)) + activeEffects.push(activeUpscaler) activeCardboard = effectiveCardboard(SessionPrefs.cardboard(this)) pushCardboard(activeCardboard) WaylandCompositor.nativeSetCardboardPoseFile(File(filesDir, ".wayland-rt/droiddeck-headpose").path) @@ -2460,9 +2809,20 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (::directTouchHold.isInitialized) directTouchHold.cancel() if (::twoFingerGestures.isInitialized) twoFingerGestures.cancel() if (::scrollTouch.isInitialized) scrollTouch.cancel() + if (sessionTouchDown || penDown) dismissTouch = true + cancelPen() scrollTouchGesture = false gesturePointerReady = false - if (sessionTouchDown) dismissTouch = true + } + + private fun cancelPen(releaseKey: Boolean = false) { + penStream.cancel(releaseKey) + penDown = false + } + + private fun notePenSeen() { + penSeen = true + SessionPrefs.setPenSeen(this) } private fun panelBounds(): android.graphics.Rect = if (Build.VERSION.SDK_INT >= 30) { @@ -2926,6 +3286,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde return super.dispatchKeyEvent(event) } } + if (penStream.holdsKey(event) || (penSettings.mode != SessionPrefs.PEN_TOUCH && PenStream.isPenKey(event))) return penStream.onKey(event) if (appTextFocus) return super.dispatchKeyEvent(event) if (!pipUi) { if (physicalInputBindings?.onKey(event, resumed && !drawerOpen && !pcKeyboardOpen && !achievementsOpen && @@ -3111,6 +3472,19 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (joyConVr?.onMotionEvent(event) == true) return true if (PadBridge.isControllerMotionEvent(event) && padMouseMode() && padMouse.onMotion(event)) return true if (padBridge?.onMotionEvent(event) == true) return true + val pen = PenStream.penIndex(event) + if (pen >= 0) when (routePen(event, pen)) { + PenRouter.Route.TOUCH -> {} + PenRouter.Route.PEN -> { + if (!appUiOwnsPointer()) return penSample(event, pen) || super.dispatchGenericMotionEvent(event) + if (super.dispatchGenericMotionEvent(event)) { + penStream.cancel() + return true + } + return !touchEditorOpen && penSample(event, pen) + } + else -> return super.dispatchGenericMotionEvent(event) + } if (event.isFromSource(android.view.InputDevice.SOURCE_MOUSE) && !drawerOpen) { if (appUiOwnsPointer()) { if (super.dispatchGenericMotionEvent(event)) return true @@ -3145,7 +3519,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde override fun dispatchTouchEvent(event: MotionEvent): Boolean { if (pipUi) return true notePress(event) - if (event.actionMasked == MotionEvent.ACTION_DOWN && event.isFromSource(InputDevice.SOURCE_TOUCHSCREEN)) { + if (event.actionMasked == MotionEvent.ACTION_DOWN && + (event.isFromSource(InputDevice.SOURCE_TOUCHSCREEN) || PenStream.penIndex(event) >= 0)) { drawerControllerActive = false gestureTouchStreamGate.reset() } @@ -3410,7 +3785,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (h == 0 && v == 0) return scrollRestX -= h scrollRestY -= v - WaylandCompositor.nativeSendSceneInput(11, ScrollTouchGestures.wheelUnits(v, out.second), ScrollTouchGestures.wheelUnits(h, out.first)) + WaylandCompositor.nativeSendSceneInput(WaylandCompositor.SCENE_AXIS, ScrollTouchGestures.wheelUnits(v, out.second), ScrollTouchGestures.wheelUnits(h, out.first)) } override fun onLongPress() = pointerListener.onLongPress() } @@ -3465,13 +3840,13 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (h == 0 && v == 0) return scrollRestX -= h scrollRestY -= v - WaylandCompositor.nativeSendSceneInput(12, v, h) + WaylandCompositor.nativeSendSceneInput(WaylandCompositor.SCENE_AXIS_FINGER, v, h) } private fun fingerScrollEnd() { scrollRestX = 0f scrollRestY = 0f - WaylandCompositor.nativeSendSceneInput(12, 0, 0) + WaylandCompositor.nativeSendSceneInput(WaylandCompositor.SCENE_AXIS_FINGER, 0, 0) } private fun placeTouchpadAtGuest(rect: android.graphics.RectF) { @@ -3741,7 +4116,26 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } }, menu = { - DroidDeckTheme { SessionMenu(docked = true) } + DroidDeckTheme { + val activeEffectsProfileId = currentScreenEffectsProfileId() + val effectsEditorTarget = + if (drawerOpen || drawerPinned) screenEffectsTarget else null + val effectsEditorProfileId = activeEffectsProfileId.takeIf { + effectsEditorTarget == SCREEN_EFFECTS_TARGET_AUTO + } + androidx.compose.runtime.LaunchedEffect(effectsEditorTarget, effectsEditorProfileId) { + when (effectsEditorTarget) { + SCREEN_EFFECTS_TARGET_AUTO -> syncActiveScreenEffectsProfile() + null -> Unit + else -> syncScreenEffectsTarget(effectsEditorTarget) + } + } + SessionMenu( + docked = true, + effectsEditorProfileId = effectsEditorProfileId, + effectsEditorTarget = effectsEditorTarget, + ) + } }, onSwap = if (bottomSwapAvailable && com.droiddeck.launcher.input.DualScreen.builtIn(target)) ({ putGameOnBottom(true) }) else null, onDeckPanel = ::selectDeckPanel, @@ -4128,6 +4522,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } if (next == routedTouchMode) return if (::touchscreenGestures.isInitialized) touchscreenGestures.cancel() + cancelPen() gesturePointerReady = false if (::touchpad.isInitialized) touchpad.cancel() if (::directTouchHold.isInitialized) directTouchHold.cancel() @@ -4206,14 +4601,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde else guestButtonsDown.remove(code) ?: evdevMouseActive val writer = if (raw) mouseWriter else null if (writer != null) writer.writeMouseButton(code.toShort(), down) - else WaylandCompositor.nativeSendSceneInput(3, code, if (down) 1 else 0) + else WaylandCompositor.nativeSendSceneInput(WaylandCompositor.SCENE_BUTTON, code, if (down) 1 else 0) } private fun sendSceneWheel(steps: Int, horizontal: Boolean = false): Unit = synchronized(heldButtons) { val writer = if (evdevMouseActive) mouseWriter else null - if (writer != null) writer.writeMouseWheel(if (horizontal) 0 else -steps, if (horizontal) steps else 0, 120) - else if (horizontal) WaylandCompositor.nativeSendSceneInput(11, 0, steps * 120) - else WaylandCompositor.nativeSendSceneInput(4, steps, 0) + if (writer != null) writer.writeMouseWheel(if (horizontal) 0 else -steps, if (horizontal) steps else 0, WaylandCompositor.WHEEL_STEP_UNITS) + else if (horizontal) WaylandCompositor.nativeSendSceneInput(WaylandCompositor.SCENE_AXIS, 0, steps * WaylandCompositor.WHEEL_STEP_UNITS) + else WaylandCompositor.nativeSendSceneInput(WaylandCompositor.SCENE_WHEEL, steps, 0) } private fun sendMouseDelta(x: Float, y: Float) { @@ -4253,7 +4648,19 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde ) } - return rect + val nativeSize = IntArray(2) + if (!WaylandCompositor.nativeOutputSize(nativeSize)) return null + val nativeWidth = nativeSize[0].takeIf { it > 0 } ?: return null + val nativeHeight = nativeSize[1].takeIf { it > 0 } ?: return null + val scaleX = width.toFloat() / nativeWidth + val scaleY = height.toFloat() / nativeHeight + + return android.graphics.RectF( + rect.left * scaleX, + rect.top * scaleY, + rect.right * scaleX, + rect.bottom * scaleY + ) } val out = SessionState.outputSize val scale = minOf(width / out.first.toFloat(), height / out.second.toFloat()) @@ -4284,7 +4691,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private var sessionTouchDown = false override fun onTouchEvent(event: MotionEvent): Boolean { - if (event.isFromSource(android.view.InputDevice.SOURCE_MOUSE)) return onMouse(event) + val pen = PenStream.penIndex(event) + val penRouted = if (pen >= 0) routePen(event, pen).takeIf { it != PenRouter.Route.TOUCH } else null + if (penRouted == null && event.isFromSource(android.view.InputDevice.SOURCE_MOUSE)) return onMouse(event) when (event.actionMasked) { MotionEvent.ACTION_DOWN -> { sessionTouchDown = true @@ -4303,19 +4712,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (event.actionMasked == MotionEvent.ACTION_UP || event.actionMasked == MotionEvent.ACTION_CANCEL) dismissTouch = false return true } - val uiBlocking = drawerOpen || achievementsOpen || gestureSettingsOpen || inputSettingsOpen || pipUi || SessionState.suspended + if (penRouted != null) return onPenTouch(event, pen, penRouted) + val uiBlocking = uiBlocksTouch() if (event.actionMasked == MotionEvent.ACTION_DOWN && !uiBlocking && routedTouchMode != SessionPrefs.TOUCH_GESTURES) { scrollTouchGesture = scrollTouchMode() scrollRestX = 0f scrollRestY = 0f } - val snapshot = com.droiddeck.launcher.input.TouchRouter.Snapshot( - uiBlocking = uiBlocking, - mode = routedTouchMode, - scrollLayer = scrollTouchGesture, - steamSession = SessionState.mode == SessionService.MODE_STEAM, - steamDesktopUi = SessionState.steamUi == "desktop", - ) + val snapshot = fingerTouchSnapshot(uiBlocking) val route = com.droiddeck.launcher.input.TouchRouter.decide(snapshot) if (route != touchRoute) { Log.i(TAG, "touch route $touchRoute -> $route (mode=$routedTouchMode steamUi=${SessionState.steamUi} scrollLayer=$scrollTouchGesture)") @@ -4343,17 +4747,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (threeFingerTap.active || wasActive) return true } if (route == com.droiddeck.launcher.input.TouchRouter.Route.TOUCHPAD) { - val rect = (if (pointerLocked) drawnRect() else pointerSurfaceRect()) ?: return false - if (touchpad.bounds != rect) { - val fresh = touchpad.bounds.width() <= 1f - touchpad.bounds = rect - if (fresh) touchpad.place(rect.centerX(), rect.centerY()) - } - if (event.actionMasked == MotionEvent.ACTION_DOWN) { - touchpad.desktop = SessionState.mode == SessionService.MODE_DESKTOP - placeTouchpadAtGuest(rect) - } - touchpad.onTouch(event) + touchpadTouch(event) } else { dispatchDirectTouch(event) } @@ -4361,6 +4755,92 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } } + private fun uiBlocksTouch(): Boolean = + drawerOpen || achievementsOpen || gestureSettingsOpen || inputSettingsOpen || pipUi || SessionState.suspended + + private fun fingerTouchSnapshot(uiBlocking: Boolean) = com.droiddeck.launcher.input.TouchRouter.Snapshot( + uiBlocking = uiBlocking, + mode = routedTouchMode, + scrollLayer = scrollTouchGesture, + steamSession = SessionState.mode == SessionService.MODE_STEAM, + steamDesktopUi = SessionState.steamUi == "desktop", + ) + + private fun touchpadTouch(event: MotionEvent): Boolean { + val rect = (if (pointerLocked) drawnRect() else pointerSurfaceRect()) ?: return false + if (touchpad.bounds != rect) { + val fresh = touchpad.bounds.width() <= 1f + touchpad.bounds = rect + if (fresh) touchpad.place(rect.centerX(), rect.centerY()) + } + if (event.actionMasked == MotionEvent.ACTION_DOWN) { + touchpad.desktop = SessionState.mode == SessionService.MODE_DESKTOP + placeTouchpadAtGuest(rect) + } + return touchpad.onTouch(event) + } + + private fun routePen(event: MotionEvent, pen: Int): PenRouter.Route { + if (!penSeen) notePenSeen() + val action = event.actionMasked + if (action == MotionEvent.ACTION_HOVER_ENTER || action == MotionEvent.ACTION_HOVER_MOVE || action == MotionEvent.ACTION_HOVER_EXIT) penDown = false + val own = PenStream.isPenAction(event, pen) + val starts = own && (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_POINTER_DOWN) + val route = penRoute.takeIf { penDown && !starts } ?: decidePen() + if (own) penDown = starts + return route + } + + private fun decidePen(): PenRouter.Route { + val mode = penSettings.mode + val route = PenRouter.decide(uiBlocksTouch(), mode, glassesOutputActive, programLocksPointer()) + if (route != penRoute) { + if (penRoute == PenRouter.Route.PEN) penStream.cancel() + Log.i(TAG, "pen route $penRoute -> $route (mode=$mode)") + penRoute = route + } + return route + } + + private fun onPenTouch(event: MotionEvent, pen: Int, route: PenRouter.Route): Boolean { + if (route == PenRouter.Route.RELATIVE && event.pointerCount > 1 && + com.droiddeck.launcher.input.TouchRouter.decide(fingerTouchSnapshot(uiBlocksTouch())) == + com.droiddeck.launcher.input.TouchRouter.Route.TOUCHPAD) { + touchpadTouch(event) + return true + } + if (event.pointerCount > 1) { + var fingers = 0 + for (index in 0 until event.pointerCount) if (!PenStream.isPen(event, index)) fingers = fingers or (1 shl event.getPointerId(index)) + event.pointerSubset(fingers)?.let { split -> try { onTouchEvent(split) } finally { split.recycle() } } + } + when (route) { + PenRouter.Route.PEN -> penSample(event, pen) + PenRouter.Route.RELATIVE -> { + val split = if (event.pointerCount == 1) MotionEvent.obtain(event) else event.pointerSubset(1 shl event.getPointerId(pen)) + split?.let { + try { + if (it.actionMasked == MotionEvent.ACTION_UP && it.flags and MotionEvent.FLAG_CANCELED != 0) it.action = MotionEvent.ACTION_CANCEL + touchpadTouch(it) + } finally { it.recycle() } + } + } + else -> {} + } + return true + } + + private fun penSample(event: MotionEvent, pen: Int): Boolean { + val area = pointerSurfaceRect() ?: return false + val view = outputView() + if (!penStream.onMotion(event, pen, area, view.width, view.height)) return false + if (penStream.inProximity) { + if (pointerLocked) releaseDesktopMouseGrab() + showCursor(event.getX(pen).coerceIn(area.left, area.right), event.getY(pen).coerceIn(area.top, area.bottom), fromMouse = true) + } + return true + } + private val directTouchSink = object : DirectTouchHold.Touch { override fun down(pointerId: Int, x: Float, y: Float) = sendDirectTouch(0, pointerId, x, y) override fun move(pointerId: Int, x: Float, y: Float) = sendDirectTouch(1, pointerId, x, y) @@ -4446,7 +4926,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } private fun isHardwareMouse(d: InputDevice?): Boolean = - d != null && !d.isVirtual && (d.supportsSource(InputDevice.SOURCE_MOUSE) || d.supportsSource(InputDevice.SOURCE_MOUSE_RELATIVE)) + d != null && !d.isVirtual && !d.supportsSource(InputDevice.SOURCE_STYLUS) && + (d.supportsSource(InputDevice.SOURCE_MOUSE) || d.supportsSource(InputDevice.SOURCE_MOUSE_RELATIVE)) /** Android also sends the Back and Forward buttons as key events, so they are handled as keys. */ private fun guestMouseButton(actionButton: Int): Int? = when (actionButton) { @@ -4456,36 +4937,47 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde else -> PointerGestures.BTN_LEFT } - private fun mouseAttached(): Boolean = InputDevice.getDeviceIds().any { id -> + private fun mouseAttached(): Boolean = usbMouse.active || InputDevice.getDeviceIds().any { id -> val d = InputDevice.getDevice(id) isHardwareMouse(d) && d?.supportsSource(InputDevice.SOURCE_TOUCHPAD) != true } private fun externalMouseAttached(): Boolean { - lastExternalMouse = InputDevice.getDeviceIds().map { InputDevice.getDevice(it) } - .firstOrNull { device -> device != null && com.droiddeck.launcher.input.MouseBackInput.isExternalMouse(device) } + lastExternalMouse = com.droiddeck.launcher.input.MouseBackInput.externalMouse( + InputDevice.getDeviceIds().map { InputDevice.getDevice(it) }) return lastExternalMouse != null } - private fun relativeMouseAttached(): Boolean = !isInMultiWindowMode && !glassesOutputActive && InputDevice.getDeviceIds().any { id -> - val d = InputDevice.getDevice(id) - isHardwareMouse(d) && d?.supportsSource(InputDevice.SOURCE_TOUCHPAD) != true - } + private fun relativeMouseAttached(): Boolean = !isInMultiWindowMode && !glassesOutputActive && mouseAttached() private fun updatePointerCapture() { if (!::surfaceView.isInitialized) return val view = window.decorView - val want = (pointerLocked || relativeMouseAttached()) && resumed && hasWindowFocus() && !drawerOpen && !pcKeyboardOpen && !achievementsOpen && !inputSettingsOpen && !pipUi && !bottomOutputActive && !touchEditorOpen && mouseAttached() + val want = (pointerLocked || relativeMouseAttached()) && resumed && hasWindowFocus() && !drawerOpen && !pcKeyboardOpen && !achievementsOpen && !inputSettingsOpen && !pipUi && !bottomOutputActive && !touchEditorOpen && !wowChatOnTop && mouseAttached() releaseDesktopMouseGrab() + updateUsbMouse(want) if (want == view.hasPointerCapture()) return if (want) view.requestPointerCapture() else view.releasePointerCapture() } + private fun updateUsbMouse(want: Boolean) { + uiHandler.removeCallbacks(usbMouseFallback) + if (!want || window.decorView.hasPointerCapture()) { + if (usbMouse.active) { + usbMouse.release() + usbMenuHold.reset() + heldButtons.release(8) + } + return + } + if (!usbMouse.active) uiHandler.postDelayed(usbMouseFallback, if (pointerCaptureRefused) 0L else POINTER_CAPTURE_GRANT_MS) + } + private fun programLocksPointer(): Boolean = pointerLocked && SessionState.mode != SessionService.MODE_DESKTOP private fun desktopMouseGrabAllowed(): Boolean = - SessionState.mode == SessionService.MODE_DESKTOP && relativeMouseAttached() && !bottomOutputActive + SessionState.mode == SessionService.MODE_DESKTOP && !penStream.inProximity && relativeMouseAttached() && !bottomOutputActive private fun tapDesktopGrabKey() { val now = android.os.SystemClock.uptimeMillis() @@ -4549,6 +5041,16 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde surfaceView.pointerIcon = icon } + private fun onRelativeMouse(dx: Float, dy: Float) { + if (pointerLocked) { + sendSceneDelta(dx, dy) + cursorVisible = false + } else { + grabDesktopMouse() + moveCapturedMouse(dx, dy) + } + } + private fun onCapturedPointer(event: MotionEvent): Boolean { if (!event.isFromSource(InputDevice.SOURCE_MOUSE_RELATIVE)) return false notePress(event) @@ -4560,11 +5062,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde dx += event.getHistoricalX(i) dy += event.getHistoricalY(i) } - if (pointerLocked) sendSceneDelta(dx, dy) - else { - grabDesktopMouse() - moveCapturedMouse(dx, dy) - } + onRelativeMouse(dx, dy) } MotionEvent.ACTION_BUTTON_PRESS, MotionEvent.ACTION_BUTTON_RELEASE -> guestMouseButton(event.actionButton)?.let { heldButtons.set(8, it, event.actionMasked == MotionEvent.ACTION_BUTTON_PRESS) } @@ -4780,6 +5278,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private fun releaseHeldGuestInput() { mouseBackInput.cancel() + cancelPen(releaseKey = true) heldButtons.release(1 or 2 or 8 or 16) guestKeysDown.toList().forEach { sendGuestKey(it, false) } heldKeys.release(8 or 16 or 32) @@ -4871,6 +5370,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde scrollTouch.cancel() directTouchHold.cancel() twoFingerGestures.cancel() + cancelPen() guestKeysDown.toList().forEach { sendGuestKey(it, false) } heldKeys.clear() heldButtons.clear() @@ -5031,7 +5531,21 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (!pipUi) sessionClipboard.start() updatePadMotion() ControllerPrefs.prefs(this).registerOnSharedPreferenceChangeListener(shortcutPrefListener) + SessionPrefs.sessionPrefs(this).registerOnSharedPreferenceChangeListener(screenEffectsProfilePrefListener) + observedScreenEffectsProfileId = SessionPrefs.activeScreenEffectsProfileId(this) readPrefs() + observedScreenEffectsProfileId = SessionPrefs.activeScreenEffectsProfileId(this) + if (CompositorHost.isStarted) { + syncActiveScreenEffectsProfile() + } else if (screenEffectsTarget == SCREEN_EFFECTS_TARGET_AUTO) { + effects = SessionPrefs.screenEffects(this, observedScreenEffectsProfileId) + upscaler = SessionPrefs.screenEffectsUpscaler(this, observedScreenEffectsProfileId) + } + if (screenEffectsTarget != SCREEN_EFFECTS_TARGET_AUTO) { + val editorProfileId = screenEffectsProfileIdForTarget(screenEffectsTarget) + effects = SessionPrefs.screenEffects(this, editorProfileId) + upscaler = SessionPrefs.screenEffectsUpscaler(this, editorProfileId) + } refreshInputProfile() refreshControls() if (::pip.isInitialized) pip.resumed() @@ -5053,6 +5567,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (::touchpad.isInitialized) touchpad.cancel() if (::directTouchHold.isInitialized) directTouchHold.cancel() if (::twoFingerGestures.isInitialized) twoFingerGestures.cancel() + cancelPen(releaseKey = true) uiHandler.removeCallbacks(clearRecognizedGesture) uiHandler.removeCallbacks(cursorResync) val screenOff = screenIsOff() @@ -5079,6 +5594,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde updatePadMotion() keyboard?.takeIf { it.shown }?.hide() SessionPrefs.sessionPrefs(this).unregisterOnSharedPreferenceChangeListener(cardboardPrefListener) + SessionPrefs.sessionPrefs(this).unregisterOnSharedPreferenceChangeListener(screenEffectsProfilePrefListener) ControllerPrefs.prefs(this).unregisterOnSharedPreferenceChangeListener(shortcutPrefListener) updateHeadTracker() super.onPause() @@ -5358,7 +5874,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde } if (shown != null) { closeSecondScreen(reset = false) - val screen = com.droiddeck.launcher.ui.BottomGameScreen(this, shown, this, ::onBottomGameTouch) + val screen = com.droiddeck.launcher.ui.BottomGameScreen(this, shown, this, ::onBottomGameTouch, ::onBottomGameHover) bottomGame = screen surfaceW = 0 surfaceH = 0 @@ -5410,9 +5926,23 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde if (surfaceView.holder.surface?.isValid == true) surfaceCreated(surfaceView.holder) } + private fun onBottomGameHover(event: MotionEvent): Boolean { + val pen = PenStream.penIndex(event) + if (pipUi || pen < 0) return false + return when (routePen(event, pen)) { + PenRouter.Route.TOUCH -> false + PenRouter.Route.PEN -> { + notePress(event) + penSample(event, pen) + true + } + else -> true + } + } + private fun onBottomGameTouch(event: MotionEvent): Boolean { if (pipUi) return true - if (!event.isFromSource(InputDevice.SOURCE_TOUCHSCREEN)) return false + if (!event.isFromSource(InputDevice.SOURCE_TOUCHSCREEN) && PenStream.penIndex(event) < 0) return false notePress(event) if (event.actionMasked == MotionEvent.ACTION_DOWN) { drawerControllerActive = false @@ -5687,6 +6217,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde steamVrRecovery.close() uiHandler.removeCallbacks(steamTouchRetry) uiHandler.removeCallbacks(cursorResync) + uiHandler.removeCallbacks(usbMouseFallback) + usbMouse.close() releaseEvdevMouse() if (runtimeRemovalBlocked) { super.onDestroy(); return } watching = false @@ -5713,6 +6245,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde padBridge?.stop() DeckControls.clearRouter(inputRouter) inputRouter = null + cancelPen() heldKeys.clear() heldButtons.clear() steamController?.stop() @@ -5815,6 +6348,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback, com.droidde private const val FIELD_SETTLE_MS = 200L private const val BTN_SIDE = 0x113 private const val BTN_EXTRA = 0x114 + private val USB_MOUSE_BUTTONS = intArrayOf(PointerGestures.BTN_LEFT, PointerGestures.BTN_RIGHT, PointerGestures.BTN_MIDDLE, BTN_SIDE, BTN_EXTRA) + private const val POINTER_CAPTURE_GRANT_MS = 500L private const val DESKTOP_GRAB_TAP_MS = 500L private const val DESKTOP_GRAB_MAX_TAPS = 8 private const val DESKTOP_GRAB_RETRY_MS = 30_000L diff --git a/app/src/main/java/com/droiddeck/launcher/UpdatesMenu.kt b/app/src/main/java/com/droiddeck/launcher/UpdatesMenu.kt index ff04640e91..f505ab8961 100644 --- a/app/src/main/java/com/droiddeck/launcher/UpdatesMenu.kt +++ b/app/src/main/java/com/droiddeck/launcher/UpdatesMenu.kt @@ -96,7 +96,17 @@ internal class UpdatesMenu(private val activity: Activity, private val ui: Handl percent = 0 Thread({ val result = runCatching { - val file = SelfInstaller.download(activity, apk) { pct -> ui.post { percent = pct } } + val file = try { + SelfInstaller.download(activity, apk) { pct -> ui.post { percent = pct } } + } catch (e: java.io.IOException) { + // Each push replaces a test build's APK, so a list read before the push names a file that is gone. + if (r.pr <= 0) throw e + val fresh = runCatching { AppUpdates.refresh(activity) }.getOrNull() ?: throw e + ui.post { catalog = fresh } + val newer = fresh.tests.firstOrNull { it.tag == r.tag }?.apk?.takeIf { it.url != apk.url } ?: throw e + ui.post { percent = 0 } + SelfInstaller.download(activity, newer) { pct -> ui.post { percent = pct } } + } ui.post { stage = activity.getString(R.string.upd_stage_installing); percent = -1 } SelfInstaller.install(activity, file) { id -> session = id } } diff --git a/app/src/main/java/com/droiddeck/launcher/audio/PulseAudioComponent.java b/app/src/main/java/com/droiddeck/launcher/audio/PulseAudioComponent.java index 08c463dfdc..d3495a353d 100644 --- a/app/src/main/java/com/droiddeck/launcher/audio/PulseAudioComponent.java +++ b/app/src/main/java/com/droiddeck/launcher/audio/PulseAudioComponent.java @@ -16,6 +16,8 @@ import java.nio.file.Files; import java.nio.file.StandardCopyOption; import java.util.ArrayList; import java.util.concurrent.TimeUnit; +import java.util.function.IntConsumer; +import java.util.function.IntSupplier; public class PulseAudioComponent extends SessionPart { private static final String TAG = "PulseAudio"; @@ -29,7 +31,55 @@ public class PulseAudioComponent extends SessionPart { private final File deviceControls; private File logFile; private final String micFifoPath; - private volatile int pid = -1; + private final HostLifecycle host = new HostLifecycle(Process::killProcess); + + static final class HostLifecycle { + volatile int pid = -1; + private long generation; + private long launches; + private final IntConsumer terminate; + + HostLifecycle(IntConsumer terminate) { + this.terminate = terminate; + } + + synchronized long begin() { + stop(); + return generation; + } + + synchronized void stop() { + generation++; + if (pid > 1) terminate.accept(pid); + pid = -1; + } + + synchronized boolean launch(long expected, IntSupplier launch) { + if (expected != generation) return false; + launches++; + pid = launch.getAsInt(); + return true; + } + + synchronized boolean current(long expected) { + return expected == generation; + } + + /** The latest launch; a sink guard holds it so it never reconfigures a host started after its own. */ + synchronized long token() { + return launches; + } + + synchronized boolean live(long token) { + return token == launches && pid > 1; + } + + synchronized boolean exited(long expected) { + if (expected != generation || pid <= 1) return false; + pid = -1; + return true; + } + } public PulseAudioComponent(Context context) { this(context, null); @@ -64,7 +114,12 @@ public class PulseAudioComponent extends SessionPart { @Override public void start() { - stop(); + start(host.begin()); + } + + private synchronized void start(long generation) { + // An exit callback's restart can be overtaken by a newer start; it must not touch the newer host's socket. + if (!host.current(generation)) return; if (!workingDir.isDirectory()) { workingDir.mkdirs(); FileUtils.chmod(workingDir, 0771); @@ -118,17 +173,23 @@ public class PulseAudioComponent extends SessionPart { + " -n --file=default.pa --daemonize=false --use-pid-file=false --exit-idle-time=-1" + " --log-level=info"; final java.io.PrintWriter out = openLog(); - pid = HostProcess.start(command, env.toArray(new String[0]), workingDir, null, + if (!host.launch(generation, () -> HostProcess.start(command, env.toArray(new String[0]), workingDir, status -> { + if (host.exited(generation)) { + Log.w(TAG, "audio host exited with status " + status + "; restarting"); + start(generation); + } + }, line -> { Log.i(TAG, line); if (out != null) synchronized (out) { out.println(line); out.flush(); } - }); - Thread guard = new Thread(() -> ensureClientSink(out), "pulse-sink-guard"); + }))) return; + long token = host.token(); + Thread guard = new Thread(() -> ensureClientSink(out, token), "pulse-sink-guard"); guard.setDaemon(true); guard.start(); } - private void ensureClientSink(java.io.PrintWriter out) { + private void ensureClientSink(java.io.PrintWriter out, long token) { try { // Nothing that may block (a sink whose AAudio open hangs: a Galaxy S24 FE (US) hung the // daemon's start-up loading one from default.pa) is loaded by the daemon itself; the @@ -137,14 +198,14 @@ public class PulseAudioComponent extends SessionPart { long deadline = started + 30000L; String sinks = null; boolean socketSeen = false; - while (System.currentTimeMillis() < deadline && pid > 1) { + while (System.currentTimeMillis() < deadline && host.live(token)) { socketSeen |= socket().exists(); - if (socketSeen && (sinks = pactl("list", "short", "sinks")) != null) break; + if (socketSeen && (sinks = pactlFor(token, "list", "short", "sinks")) != null) break; try { Thread.sleep(250L); } catch (InterruptedException e) { Thread.currentThread().interrupt(); return; } } note(out, "client sink: daemon " + (sinks != null ? "answered" : "did not answer") + " after " + (System.currentTimeMillis() - started) + " ms (socket " + (socketSeen ? "present" : "never appeared") + ", pactl " - + (new File(workingDir, "pactl").isFile() ? "present" : "MISSING") + ", daemon pid " + pid + ")"); + + (new File(workingDir, "pactl").isFile() ? "present" : "MISSING") + ", daemon pid " + host.pid + ")"); String line; if (sinks == null) { line = "== client sink: the daemon did not answer in 30 s; no fallback attempted"; @@ -155,15 +216,15 @@ public class PulseAudioComponent extends SessionPart { // still switching the output route as the session starts (seen on a Galaxy S24 FE): // try DirectAudio again, then the plain sink, a few times over ten seconds. String loadedAs = null; - for (int attempt = 1; attempt <= 5 && loadedAs == null && pid > 1; attempt++) { + for (int attempt = 1; attempt <= 5 && loadedAs == null && host.live(token); attempt++) { try { Thread.sleep(2000L); } catch (InterruptedException e) { Thread.currentThread().interrupt(); return; } - if (pactl("load-module", "module-directaudio-native-sink", "sink_name=DirectAudio", "performance_mode=1", + if (pactlFor(token, "load-module", "module-directaudio-native-sink", "sink_name=DirectAudio", "performance_mode=1", "adaptive=1", "decay=0", "limiter=1", "watchdog=1", "volume=1.0", "control_dir=" + deviceControls) != null - && pactl("set-default-sink", "DirectAudio") != null) { + && pactlFor(token, "set-default-sink", "DirectAudio") != null) { loadedAs = "DirectAudio on attempt " + attempt; - } else if (pactl("load-module", "module-aaudio-sink", "sink_name=AAudioSink", + } else if (pactlFor(token, "load-module", "module-aaudio-sink", "sink_name=AAudioSink", "performance_mode=" + (attempt == 1 ? "1" : "0"), "adaptive=1", "volume=1.0", "control_dir=" + deviceControls) != null - && pactl("set-default-sink", "AAudioSink") != null) { + && pactlFor(token, "set-default-sink", "AAudioSink") != null) { loadedAs = "the plain AAudio sink (AAudioSink) on attempt " + attempt; } } @@ -186,10 +247,14 @@ public class PulseAudioComponent extends SessionPart { if (out != null) synchronized (out) { out.println(line); out.flush(); } } + private String pactlFor(long token, String... args) { + return host.live(token) ? pactl(args) : null; + } + /** Runs pactl against this daemon; its stdout, or null when it failed or timed out. */ private String pactl(String... args) { File pactl = new File(workingDir, "pactl"); - if (!pactl.isFile() || pid <= 1) return null; + if (!pactl.isFile() || host.pid <= 1) return null; java.lang.Process process = null; try { File modules = new File(workingDir, "modules/arm64"); @@ -231,10 +296,7 @@ public class PulseAudioComponent extends SessionPart { @Override public void stop() { - if (pid != -1) { - Process.killProcess(pid); - pid = -1; - } + host.stop(); } public boolean setSinkSuspended(boolean suspended) { @@ -247,7 +309,7 @@ public class PulseAudioComponent extends SessionPart { private boolean suspend(String kind, String name, boolean suspended) { File pactl = new File(workingDir, "pactl"); - if (!pactl.isFile() || pid <= 1) { + if (!pactl.isFile() || host.pid <= 1) { Log.w(TAG, "cannot change " + kind + " state: PulseAudio control client or server unavailable"); return false; } diff --git a/app/src/main/java/com/droiddeck/launcher/core/DeviceReport.kt b/app/src/main/java/com/droiddeck/launcher/core/DeviceReport.kt index c6dd49a4c3..3c047d2e13 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/DeviceReport.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/DeviceReport.kt @@ -233,6 +233,10 @@ object DeviceReport { else "${turnip.displayName(displayId)} ${turnip.driverVersion(displayId)}".trim() k("Display driver (chosen)", if (androidChoice.isEmpty()) "Auto -> $displayLabel" else androidChoice) k(" name / version", displayLabel) + turnip.effectiveId().takeIf { it != displayId }?.let { used -> + k(" in use", if (used == "system") DeviceInfo.builtinDriverLabel(SystemVulkanDriver.isPowerVr(), runtime = false) + else "${turnip.displayName(used)} ${turnip.driverVersion(used)}".trim()) + } k(" imported available", turnip.enumerateImported().ifEmpty { listOf("none") }.joinToString(", ")) val lm = LinuxVulkanDriverManager(context) run { @@ -242,7 +246,9 @@ object DeviceReport { lm.getMinGlibc(id).let { if (it.isEmpty()) "" else " (glibc $it+)" } + if (lm.isInstalled(id)) "" else if (SystemVulkanDriver.isPowerVr()) " [MISSING - select an installed driver or Auto]" else " [MISSING - falls back to the runtime's own]" - k("Linux driver", label) + val route = DeviceInfo.hostRoute(context) + k("Linux driver", route ?: label) + if (route != null) k(" chosen, not used", label) } k("Runtime's own ICD", LinuxRuntime.vulkanIcd(context)?.path) k("Mali (Venus)", if (com.droiddeck.launcher.session.VenusComponent.wanted(context)) "in use" @@ -290,6 +296,8 @@ object DeviceReport { k("Microphone", SessionPrefs.micEnabled(context)) k("On-screen controls", SessionPrefs.oscMode(context)) k("Touch mode", SessionPrefs.touchMode(context)) + k("Pen mode", SessionPrefs.penMode(context)) + k("Pen side button", SessionPrefs.penButton(context)) k("Performance HUD", SessionPrefs.hudEnabled(context)) k("Game storage", when (val g = SessionPrefs.gameStorage(context)) { "" -> "automatic (" + (com.droiddeck.launcher.session.GameStorage.effective(context)?.path ?: "no card present") + ")" diff --git a/app/src/main/java/com/droiddeck/launcher/core/SessionLogCapture.kt b/app/src/main/java/com/droiddeck/launcher/core/SessionLogCapture.kt index c7b4a78c7c..89ec374d6d 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/SessionLogCapture.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/SessionLogCapture.kt @@ -18,7 +18,7 @@ object SessionLogCapture { private var syncer: Thread? = null @Synchronized - fun start(target: File) { + fun start(target: File, sinceMillis: Long) { stop() try { val out = target.bufferedWriter() @@ -28,7 +28,7 @@ object SessionLogCapture { writer = out this.target = target pid = HostProcess.start( - "/system/bin/logcat -v threadtime -T 1 --pid=" + Process.myPid(), + command(Process.myPid(), sinceMillis), null, target.parentFile, null, ) { line -> synchronized(this) { @@ -49,6 +49,11 @@ object SessionLogCapture { } } + internal fun command(pid: Int, sinceMillis: Long): String { + val since = if (sinceMillis > 0) "%d.%03d".format(java.util.Locale.US, sinceMillis / 1000, sinceMillis % 1000) else "1" + return "/system/bin/logcat -v threadtime -T $since --pid=$pid" + } + @Synchronized fun stopFor(dir: File) { val t = target ?: return diff --git a/app/src/main/java/com/droiddeck/launcher/core/ShortcutsListingReceiver.kt b/app/src/main/java/com/droiddeck/launcher/core/ShortcutsListingReceiver.kt deleted file mode 100644 index f9ee889bdf..0000000000 --- a/app/src/main/java/com/droiddeck/launcher/core/ShortcutsListingReceiver.kt +++ /dev/null @@ -1,11 +0,0 @@ -package com.droiddeck.launcher.core - -import android.content.BroadcastReceiver -import android.content.Context -import android.content.Intent - -class ShortcutsListingReceiver : BroadcastReceiver() { - override fun onReceive(context: Context, intent: Intent) { - if (intent.action == Intent.ACTION_MY_PACKAGE_REPLACED) SteamIntegration.syncShortcutsListing(context) - } -} diff --git a/app/src/main/java/com/droiddeck/launcher/core/SteamIntegration.kt b/app/src/main/java/com/droiddeck/launcher/core/SteamIntegration.kt index b9968ebdb5..84f87cca13 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/SteamIntegration.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/SteamIntegration.kt @@ -1,20 +1,21 @@ package com.droiddeck.launcher.core -import android.accessibilityservice.AccessibilityServiceInfo import android.content.ComponentName import android.content.Context import android.content.Intent import android.content.pm.PackageManager import android.net.Uri import android.provider.Settings -import android.view.accessibility.AccessibilityManager import com.droiddeck.launcher.HomeApp -import com.droiddeck.launcher.input.HomeButtonService import com.droiddeck.launcher.session.SessionPrefs +import com.droiddeck.shortcuts.Relay +import java.io.File object SteamIntegration { const val ACTION_SETUP = "com.droiddeck.launcher.STEAM_INTEGRATION" const val EXTRA_FEATURE = "integration_feature" + const val SHORTCUTS_STATUS = "com.droiddeck.launcher.SHORTCUTS_INSTALL_STATUS" + private const val SHORTCUTS_ASSET = "shortcuts.apk" enum class Feature { WIFI, BRIGHTNESS, HOME, SHORTCUTS } data class State( @@ -36,11 +37,7 @@ object SteamIntegration { locationOn = WifiDiscovery.locationEnabled(context), brightness = Settings.System.canWrite(context), home = HomeApp.isDefault(context), - shortcuts = context.getSystemService(AccessibilityManager::class.java) - .getEnabledAccessibilityServiceList(AccessibilityServiceInfo.FEEDBACK_ALL_MASK).any { - val service = it.resolveInfo.serviceInfo - ComponentName(service.packageName, service.name) == ComponentName(context, HomeButtonService::class.java) - }, + shortcuts = shortcutsEnabled(context), shortcutsRestricted = restrictedSettings(context), suggested = !SessionPrefs.sessionPrefs(context).getBoolean("steam_integration_seen", false), ) @@ -48,48 +45,53 @@ object SteamIntegration { private fun restrictedSettings(context: Context): Boolean { if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.TIRAMISU) return false val mode = runCatching { + val uid = context.packageManager.getApplicationInfo(Relay.PACKAGE, 0).uid context.getSystemService(android.app.AppOpsManager::class.java) - .unsafeCheckOpNoThrow("android:access_restricted_settings", android.os.Process.myUid(), context.packageName) + .unsafeCheckOpNoThrow("android:access_restricted_settings", uid, Relay.PACKAGE) }.getOrDefault(android.app.AppOpsManager.MODE_ALLOWED) return mode == android.app.AppOpsManager.MODE_ERRORED || mode == android.app.AppOpsManager.MODE_IGNORED } - private fun shortcutsComponent(context: Context) = ComponentName(context, HomeButtonService::class.java) + private val shortcutsComponent = ComponentName(Relay.PACKAGE, Relay.SERVICE) - fun shortcutsChosen(context: Context): Boolean = shortcutsSelection(context) == true - - private fun shortcutsSelection(context: Context): Boolean? { - val target = shortcutsComponent(context) + fun shortcutsEnabled(context: Context): Boolean { val enabled = runCatching { Settings.Secure.getString(context.contentResolver, Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES) - }.getOrElse { return null }.orEmpty() - return enabled.split(':').any { ComponentName.unflattenFromString(it.trim()) == target } + }.getOrNull().orEmpty() + return enabled.split(':').any { ComponentName.unflattenFromString(it.trim()) == shortcutsComponent } } - fun setShortcutsListed(context: Context, listed: Boolean) { + fun shortcutsListed(context: Context): Boolean = + context.getSystemService(android.view.accessibility.AccessibilityManager::class.java) + ?.installedAccessibilityServiceList.orEmpty() + .any { ComponentName(it.resolveInfo.serviceInfo.packageName, it.resolveInfo.serviceInfo.name) == shortcutsComponent } + + fun bundledShortcuts(context: Context): File { + val target = File(context.cacheDir, SHORTCUTS_ASSET) + context.assets.open(SHORTCUTS_ASSET).use { input -> target.outputStream().use { input.copyTo(it) } } + return target + } + + fun shortcutsInstalled(context: Context, bundled: File): Boolean { val packages = context.packageManager - val component = shortcutsComponent(context) - val state = if (listed) PackageManager.COMPONENT_ENABLED_STATE_ENABLED else PackageManager.COMPONENT_ENABLED_STATE_DISABLED - runCatching { - if (packages.getComponentEnabledSetting(component) != state) { - packages.setComponentEnabledSetting(component, state, PackageManager.DONT_KILL_APP) - } - } - } - - fun syncShortcutsListing(context: Context) { - shortcutsSelection(context)?.let { setShortcutsListed(context, it) } + @Suppress("DEPRECATION") + val installed = runCatching { packages.getPackageInfo(Relay.PACKAGE, 0).versionCode }.getOrNull() ?: return false + @Suppress("DEPRECATION") + val shipped = packages.getPackageArchiveInfo(bundled.absolutePath, 0)?.versionCode ?: return true + return installed >= shipped } fun dismissSuggestion(context: Context) { SessionPrefs.sessionPrefs(context).edit().putBoolean("steam_integration_seen", true).apply() } + fun shortcutsAppInfo() = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.parse("package:${Relay.PACKAGE}")) + fun brightnessSettings(context: Context) = Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS, Uri.parse("package:${context.packageName}")) fun shortcutSettings(context: Context): Intent { - val service = ComponentName(context, HomeButtonService::class.java).flattenToString() + val service = shortcutsComponent.flattenToString() return Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS) .putExtra(":settings:fragment_args_key", service) .putExtra(":settings:show_fragment_args", android.os.Bundle().apply { putString(":settings:fragment_args_key", service) }) diff --git a/app/src/main/java/com/droiddeck/launcher/files/FileManagerScreen.kt b/app/src/main/java/com/droiddeck/launcher/files/FileManagerScreen.kt index 2d6cd6d2c4..4da772b1e8 100644 --- a/app/src/main/java/com/droiddeck/launcher/files/FileManagerScreen.kt +++ b/app/src/main/java/com/droiddeck/launcher/files/FileManagerScreen.kt @@ -112,6 +112,10 @@ private const val HISTORY_LIMIT = 50 internal fun canNavigateUp(currentDir: File, currentRoot: File): Boolean = currentDir != currentRoot && currentDir.parentFile?.exists() == true +// Back leaves after a drive hop instead of replaying a stack of hops one press at a time. +internal fun backExitsAtRootHop(currentDir: File, currentRoot: File, previous: Pair): Boolean = + currentDir == currentRoot && previous.first == previous.second + @OptIn(ExperimentalMaterial3Api::class) @Composable fun FileManagerScreen( @@ -269,8 +273,10 @@ fun FileManagerScreen( if (showFavorites) showFavorites = false else { while (history.isNotEmpty() && !history.last().first.isDirectory) history.removeAt(history.lastIndex) - val previous = history.removeLastOrNull() - if (previous != null) { + val previous = history.lastOrNull() + if (previous != null && backExitsAtRootHop(currentDir, currentRoot, previous)) onExit?.invoke() + else if (previous != null) { + history.removeLastOrNull() currentRoot = previous.second loadDirectory(previous.first, record = false) } else if (canNavigateUp(currentDir, currentRoot)) currentDir.parentFile?.let { loadDirectory(it, record = false) } diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/GameFileSync.kt b/app/src/main/java/com/droiddeck/launcher/frontend/GameFileSync.kt index e31b86dd09..275c0e95a8 100644 --- a/app/src/main/java/com/droiddeck/launcher/frontend/GameFileSync.kt +++ b/app/src/main/java/com/droiddeck/launcher/frontend/GameFileSync.kt @@ -43,11 +43,14 @@ object GameFileSync { val storageSetting = SessionPrefs.gameStorage(context) val previousStorage = prefs(context).getString("storagePath", null) if (storageSetting.isEmpty() && prefs(context).getString("storageSetting", null) == storageSetting && previousStorage != null) { - check(File(previousStorage).isDirectory) { context.getString(R.string.game_sync_err_previous_sd) } + check(libraryReadable(File(previousStorage))) { context.getString(R.string.game_sync_err_previous_sd) } } - storage?.let { check(File(it.path).listFiles() != null) { context.getString(R.string.game_sync_err_game_storage) } } + storage?.let { check(libraryReadable(File(it.path))) { context.getString(R.string.game_sync_err_game_storage) } } AddedGames.roots(context).forEach { check(it.host.listFiles() != null) { context.getString(R.string.game_sync_err_added_games) } } GameFiles.sync(context, folder, Library.launchableGames(context, strictRead = true)) prefs(context).edit().putString("storageSetting", storageSetting).putString("storagePath", storage?.path).apply() } + + internal fun libraryReadable(dir: File): Boolean = + dir.listFiles() != null || (!dir.exists() && dir.parentFile?.isDirectory == true) } diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt b/app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt index f14d92da2f..419ea0b192 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt @@ -563,7 +563,7 @@ object Glasses { val device = selected?.first val m = selected?.second val controllable = m?.let(::canOpenModel) == true - val permitted = controllable && device != null && (m === XrealModel || usb.hasPermission(device)) + val permitted = controllable && device != null && (m is XrealModel || usb.hasPermission(device)) val identity = device?.let { GlassesModeState.Device(it.productId, if (permitted) runCatching { it.serialNumber }.getOrNull() else null) } @@ -614,9 +614,9 @@ object Glasses { sbs = sbsByDisplay, switching3d = modeState.pendingStereo, brightnessMax = m?.brightnessMax ?: 8, volumeMax = m?.volumeMax ?: 8, - sunblock = if (m === XrealModel) it.sunblock else _settings.value.sunblock ?: it.sunblock, + sunblock = if (m is XrealModel) it.sunblock else _settings.value.sunblock ?: it.sunblock, hardwareControls = m?.hardwareControls == true && - (device?.vendorId == VitureProtocol.VENDOR_ID || m === XrealModel || m is RokidModel), + (device?.vendorId == VitureProtocol.VENDOR_ID || m is XrealModel || m is RokidModel), supportsDisplayModeControl = m?.supportsDisplayModeControl == true, hasSunblock = m?.hasSunblock == true, diagonalFovDeg = m?.diagonalFovDeg ?: 46f, @@ -624,7 +624,7 @@ object Glasses { noSignal = noSignal, sbs90 = m?.sbs90 == true, rates2d = m?.rates2d ?: listOf(60, 90, 120), - experimental = m === XrealModel || (m is VitureProtocol.Model && m.family == VitureProtocol.Family.PRO2 && !m.needsSdk), + experimental = m is XrealModel || (m is VitureProtocol.Model && m.family == VitureProtocol.Family.PRO2 && !m.needsSdk), supportsScreen3dof = link?.hasImu == true, supports30Hz = display?.let(::supports30Hz) == true, supportsSpatial = (link as? VitureSdkLink)?.isCarina == true, @@ -660,8 +660,8 @@ object Glasses { else VitureSdk.marketName(device.productId)?.let(VitureProtocol::sdkModel) ?: VitureProtocol.model(device.productId, name) } - else if (XrealModel.matches(device.vendorId, device.productId)) XrealModel - else RokidModel.model(device.vendorId, device.productId, name) + else XrealModel.model(device.vendorId, device.productId) + ?: RokidModel.model(device.vendorId, device.productId, name) ?: RayNeoModel.model(device.vendorId, device.productId, name) } @@ -729,8 +729,8 @@ object Glasses { VitureSdkLink.open(usb, device, File(app.noBackupFilesDir, "viture"), sdkListener(generation), (model as? VitureProtocol.Model)?.family, spatial) } else VitureLink.open(usb, device, linkListener(generation)) - } else if (model === XrealModel) { - XrealLink.open(app, xrealListener(generation)) + } else if (model is XrealModel) { + XrealLink.open(app, model as XrealModel, xrealListener(generation)) } else if (model is RokidModel) { RokidLink.open(usb, device, rokidListener(generation)) } else { diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/XrealLink.kt b/app/src/main/java/com/droiddeck/launcher/glasses/XrealLink.kt index 18ce636eed..d2ea72d4d4 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/XrealLink.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/XrealLink.kt @@ -10,6 +10,7 @@ import java.util.concurrent.atomic.AtomicReference internal class XrealLink internal constructor( private val connector: XrealConnector, private val listener: Listener, + private val model: XrealModel = XrealModel.ONE_S, ) : GlassesLink { interface Listener { fun onReady() @@ -29,7 +30,8 @@ internal class XrealLink internal constructor( private val worker = Thread(::run, "xreal-control").apply { isDaemon = true; start() } companion object { - fun open(context: Context, listener: Listener) = XrealLink(AndroidXrealConnector(context), listener) + fun open(context: Context, model: XrealModel, listener: Listener) = + XrealLink(AndroidXrealConnector(context), listener, model) } override fun send(msgId: Int, payload: ByteArray): Boolean { @@ -43,9 +45,10 @@ internal class XrealLink internal constructor( if (msgId == VitureProtocol.MSG_GET_IMU) return true val valid = when (msgId) { VitureProtocol.MSG_GET_DISPLAY -> true - VitureProtocol.MSG_DISPLAY -> value in 2..5 || value == XrealModel.NATIVE_60HZ - VitureProtocol.MSG_BRIGHTNESS -> value in 0..9 - VitureProtocol.MSG_FILM -> value in 0..1 + VitureProtocol.MSG_DISPLAY -> if (model.stereoOnlyControl) value == 5 || value == XrealModel.NATIVE_60HZ + else value in 2..5 || value == XrealModel.NATIVE_60HZ + VitureProtocol.MSG_BRIGHTNESS -> !model.stereoOnlyControl && value in 0..9 + VitureProtocol.MSG_FILM -> !model.stereoOnlyControl && value in 0..1 else -> false } return valid && commands.offer(Command(msgId, value)) @@ -61,12 +64,12 @@ internal class XrealLink internal constructor( channels = connector.connect() connection.set(channels) if (!running) break - val control = XrealControl(channels) + val control = XrealControl(channels, stereoOnly = model.stereoOnlyControl) listener.onValue(VitureProtocol.MSG_GET_DISPLAY, control.display()) val current = channels reports = Thread({ try { - var filter = XrealOrientationFilter() + var filter = XrealOrientationFilter(model.flipsYz) var wasTracking = false var lastSensor = System.nanoTime() while (running && connection.get() === current) { @@ -75,7 +78,7 @@ internal class XrealLink internal constructor( if (sample != null) { lastSensor = System.nanoTime() val enabled = tracking - if (enabled && !wasTracking) filter = XrealOrientationFilter() + if (enabled && !wasTracking) filter = XrealOrientationFilter(model.flipsYz) wasTracking = enabled if (enabled) filter.update(sample)?.let { if (running && ready && tracking && connection.get() === current) @@ -149,7 +152,11 @@ internal class XrealLink internal constructor( } } -internal class XrealControl(private val channels: XrealChannels, private val settleDelayMs: Long = 150) { +internal class XrealControl( + private val channels: XrealChannels, + private val settleDelayMs: Long = 150, + private val stereoOnly: Boolean = false, +) { private var transaction = 0 private fun exchange(command: Int, value: Int? = null): ByteArray { transaction = if (transaction == Int.MAX_VALUE) 1 else transaction + 1 @@ -163,26 +170,42 @@ internal class XrealControl(private val channels: XrealChannels, private val set throw IOException("XREAL control response was not received") } fun display(): Int { + if (stereoOnly) return stereoDisplay() val reply = exchange(XrealProtocol.GET_DISPLAY) return XrealProtocol.numeric(reply)?.takeIf { it in 2..5 || it == XrealModel.NATIVE_60HZ } ?: throw IOException("Unsupported XREAL display response: ${reply.take(32).joinToString("") { "%02x".format(it) }}") } + private fun stereoDisplay(): Int { + val reply = exchange(XrealProtocol.GET_INPUT) + return when { + XrealProtocol.acknowledged(reply) -> XrealModel.NATIVE_60HZ + else -> when (XrealProtocol.numeric(reply)) { + 0 -> XrealModel.NATIVE_60HZ + 1 -> 5 + else -> throw IOException("Unsupported XREAL stereo response: ${reply.take(32).joinToString("") { "%02x".format(it) }}") + } + } + } fun changeDisplay(mode: Int): Int { val stereo = mode == 5 set(XrealProtocol.SET_INPUT, if (stereo) 1 else 0) val current = awaitDisplay { (it == 5) == stereo } - if (current == mode) return current + if (current == mode || stereoOnly) return current set(XrealProtocol.SET_DISPLAY, mode) return awaitDisplay { it == mode } } private fun awaitDisplay(matches: (Int) -> Boolean): Int { val deadline = System.nanoTime() + 8_000_000_000L repeat(40) { - val reply = exchange(XrealProtocol.GET_DISPLAY) - val value = XrealProtocol.numeric(reply) - if (value != null && matches(value)) return value - if (value == null && !XrealProtocol.acknowledged(reply)) - throw IOException("Invalid XREAL display transition response") + if (stereoOnly) { + stereoDisplay().let { if (matches(it)) return it } + } else { + val reply = exchange(XrealProtocol.GET_DISPLAY) + val value = XrealProtocol.numeric(reply) + if (value != null && matches(value)) return value + if (value == null && !XrealProtocol.acknowledged(reply)) + throw IOException("Invalid XREAL display transition response") + } if (System.nanoTime() > deadline) throw IOException("XREAL display transition timed out") Thread.sleep(settleDelayMs) } diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/XrealModel.kt b/app/src/main/java/com/droiddeck/launcher/glasses/XrealModel.kt index 2de2236c78..70b81995e1 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/XrealModel.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/XrealModel.kt @@ -1,25 +1,63 @@ package com.droiddeck.launcher.glasses -object XrealModel : GlassesModel { - const val VENDOR_ID = 0x3318 - const val PRODUCT_1S = 0x043e - const val NATIVE_60HZ = 29 - override val name = "XREAL 1S" +internal class XrealModel private constructor( + override val name: String, + val family: Family, + override val diagonalFovDeg: Float, +) : GlassesModel { + enum class Family { + ONE_S, + ONE, + AURA, + } + override val controllable = true override val brightnessMax = 9 override val volumeMax = 0 - override val hasSunblock = true - override val diagonalFovDeg = 52f + override val hasSunblock get() = family == Family.ONE_S + override val hardwareControls get() = family == Family.ONE_S override val sbs90 = false + override val rates2d get() = if (family == Family.ONE_S) super.rates2d else listOf(60) - fun matches(vid: Int, pid: Int) = vid == VENDOR_ID && pid == PRODUCT_1S - fun isDisplay(name: String) = name.contains("XREAL", ignoreCase = true) + // Only the 1S has been exercised with SET_DISPLAY; the Aura is known to reboot on an unexpected index. + val stereoOnlyControl get() = family != Family.ONE_S + + // The Aura reports x right, y up, z back; the rest of the One family is a half turn about x from it. + val flipsYz get() = family != Family.AURA override fun mode(hz: Int, sbs: Boolean) = when { sbs -> 5 + stereoOnlyControl -> NATIVE_60HZ hz >= 120 -> 4 hz >= 90 -> 3 else -> NATIVE_60HZ } override fun modeForStep(step: Int): Int? = null + + override fun toString() = name + + companion object { + const val VENDOR_ID = 0x3318 + const val PRODUCT_1S = 0x043e + const val NATIVE_60HZ = 29 + + val ONE_S = XrealModel("XREAL 1S", Family.ONE_S, 52f) + val ONE = XrealModel("XREAL One", Family.ONE, 50f) + val ONE_PRO = XrealModel("XREAL One Pro", Family.ONE, 57f) + val ONE_PRO_PLUS = XrealModel("XREAL One Pro+", Family.ONE, 57f) + val AURA = XrealModel("XREAL Aura", Family.AURA, 70f) + + // The odd product ids one below these are the glasses' recovery mode. + private val products = mapOf( + PRODUCT_1S to ONE_S, + 0x0438 to ONE, + 0x0436 to ONE_PRO, + 0x0444 to ONE_PRO_PLUS, + 0x043a to AURA, + ) + + fun model(vid: Int, pid: Int): XrealModel? = if (vid == VENDOR_ID) products[pid] else null + fun matches(vid: Int, pid: Int) = model(vid, pid) != null + fun isDisplay(name: String) = name.contains("XREAL", ignoreCase = true) + } } diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/XrealOrientationFilter.kt b/app/src/main/java/com/droiddeck/launcher/glasses/XrealOrientationFilter.kt index c10bb94735..8bf8dd30e7 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/XrealOrientationFilter.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/XrealOrientationFilter.kt @@ -2,12 +2,13 @@ package com.droiddeck.launcher.glasses import kotlin.math.abs -internal class XrealOrientationFilter { +internal class XrealOrientationFilter(private val flipYz: Boolean = true) { private val fusion = ImuFusion() fun update(sample: XrealProtocol.Sample): FloatArray? = fusion.update(sample.timeNs, - Vec3(sample.accel.x, -sample.accel.y, -sample.accel.z), - Vec3(sample.gyro.x, -sample.gyro.y, -sample.gyro.z)) + sample.accel.headAxes(), sample.gyro.headAxes()) + + private fun Vec3.headAxes() = if (flipYz) Vec3(x, -y, -z) else this } internal class ImuFusion { diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/XrealProtocol.kt b/app/src/main/java/com/droiddeck/launcher/glasses/XrealProtocol.kt index 09bed01796..dbf6bb031e 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/XrealProtocol.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/XrealProtocol.kt @@ -13,6 +13,7 @@ internal object XrealProtocol { const val REPORT = 0x2836 const val GET_DISPLAY = 0x275e const val SET_DISPLAY = 0x275f + const val GET_INPUT = 0x2821 const val SET_INPUT = 0x2822 const val SET_BRIGHTNESS = 0x271c const val SET_DIMMER = 0x2727 diff --git a/app/src/main/java/com/droiddeck/launcher/gpu/DeviceInfo.kt b/app/src/main/java/com/droiddeck/launcher/gpu/DeviceInfo.kt index 148555c5c3..bf44d7eec8 100644 --- a/app/src/main/java/com/droiddeck/launcher/gpu/DeviceInfo.kt +++ b/app/src/main/java/com/droiddeck/launcher/gpu/DeviceInfo.kt @@ -145,16 +145,22 @@ object DeviceInfo { private fun drivers(context: Context, gpu: GpuInfo) = Section("Drivers DroidDeck uses", buildList> { add("Driver mode", SessionPrefs.gpuDriverMode(context)) val turnip = TurnipDriver(context) - val choice = SessionPrefs.androidDriver(context).ifEmpty { turnip.autoId() } + val choice = turnip.effectiveId() val powerVr = gpu.family == GpuInfo.Family.POWERVR add("Display driver", if (choice == "system") builtinDriverLabel(powerVr, runtime = false) else "${turnip.displayName(choice)} ${turnip.driverVersion(choice)}".trim()) val linux = LinuxVulkanDriverManager(context) val id = SessionPrefs.linuxDriver(context) - add("Game driver", if (id.isEmpty()) builtinDriverLabel(powerVr, runtime = true) else "${linux.getDriverName(id)} ${linux.getDriverVersion(id)}".trim()) + add("Game driver", hostRoute(context) ?: if (id.isEmpty()) builtinDriverLabel(powerVr, runtime = true) else "${linux.getDriverName(id)} ${linux.getDriverVersion(id)}".trim()) if (gpu.oneUi8Gen2) add("Note", "One UI on an 8 Gen 2: needs the OneUI Turnip build") }) + internal fun hostRoute(context: Context): String? = when { + com.droiddeck.launcher.session.VenusComponent.wanted(context) -> "Mali (Venus)" + com.droiddeck.launcher.core.DeviceSupport.vkBridge(context) -> "the Mali bridge" + else -> null + } + /** Shared by the device card and the session report, which are written in English. */ internal fun builtinDriverLabel(powerVr: Boolean, runtime: Boolean): String = when { powerVr -> "System PowerVR" diff --git a/app/src/main/java/com/droiddeck/launcher/gpu/TurnipDriver.java b/app/src/main/java/com/droiddeck/launcher/gpu/TurnipDriver.java index 294f5a95b8..d8aad76348 100644 --- a/app/src/main/java/com/droiddeck/launcher/gpu/TurnipDriver.java +++ b/app/src/main/java/com/droiddeck/launcher/gpu/TurnipDriver.java @@ -34,6 +34,8 @@ public final class TurnipDriver { public static final List BUNDLED = Collections.unmodifiableList(Arrays.asList( DRIVER_A7XX, DRIVER_A8XX, com.droiddeck.launcher.session.QuestExperimental.DRIVER, DRIVER_A6XX, com.droiddeck.launcher.session.QuestExperimental.DRIVER_A6XX)); + private static final String KGSL_NODE = "/dev/kgsl-3d0"; + private static final String KGSL_SYSFS = "/sys/class/kgsl/kgsl-3d0"; private static final String OVERRIDE_FILE = "Download/droiddeck-driver"; private static final String PREFS = "graphics_driver"; private static final String KEY_HIDDEN = "hiddenBundled"; @@ -140,6 +142,25 @@ public final class TurnipDriver { return id == null ? "system" : id; } + public String effectiveId() { + String id = choose(); + return id == null || !reachesGpu(id) ? "system" : id; + } + + public boolean reachesGpu(String driverId) { + String library = libraryName(driverId); + return library == null || !needsMissingKgsl(new File(new File(contentDir, driverId), library), + kgslPresent(new File(KGSL_NODE), new File(KGSL_SYSFS))); + } + + static boolean kgslPresent(File node, File sysfs) { + return node.exists() || sysfs.exists(); + } + + static boolean needsMissingKgsl(File library, boolean kgsl) { + return !kgsl && library.isFile() && LinuxVulkanDriverManager.containsAscii(library, KGSL_NODE); + } + public void remove(String driverId) { if (driverId == null || driverId.isEmpty() || BUNDLED.contains(driverId) || driverId.contains("/") || driverId.contains("..")) return; @@ -257,6 +278,11 @@ public final class TurnipDriver { Log.e(TAG, id + " unpacked without " + library); return null; } + if (!reachesGpu(id)) { + Log.w(TAG, id + " needs " + KGSL_NODE + ", which this GPU does not have; display on the system Vulkan loader"); + DriverSetupLog.write(context, "install.no-kgsl driver=" + id); + return null; + } Log.i(TAG, "graphics driver " + id + " (" + library + ")"); DriverSetupLog.write(context, "install.ready driver=" + id + " library=" + library); return id; @@ -282,6 +308,12 @@ public final class TurnipDriver { } } if (chosen != null && !chosen.isEmpty()) { + if (SessionPrefs.GPU_DRIVERS_AUTO.equals(SessionPrefs.INSTANCE.gpuDriverMode(context)) + && SessionPrefs.INSTANCE.gpuAutoInstalled(context).contains(chosen) + && gpuDetector.get().getFamily() == GpuInfo.Family.A7XX_LOW) { + Log.i(TAG, "Auto-selected display driver does not cover Adreno 710/720/722; leaving the display driver to the system"); + return null; + } if (BUNDLED.contains(chosen)) { Log.i(TAG, "driver pinned by the user: " + chosen); return chosen; @@ -318,6 +350,10 @@ public final class TurnipDriver { Log.i(TAG, "not an Adreno GPU; leaving the display driver to the system"); return null; } + if (gpu.getFamily() == GpuInfo.Family.A7XX_LOW) { + Log.i(TAG, "no bundled display driver covers Adreno 710/720/722; leaving the display driver to the system"); + return null; + } int model = gpu.getModel(); Log.i(TAG, "gpu model: " + (model == 0 ? "unknown" : model)); return chooseByModel(model, android.os.Build.VERSION.SDK_INT); diff --git a/app/src/main/java/com/droiddeck/launcher/input/BottomScreenGuests.kt b/app/src/main/java/com/droiddeck/launcher/input/BottomScreenGuests.kt index 574536e18a..d72e6a2d92 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/BottomScreenGuests.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/BottomScreenGuests.kt @@ -1,10 +1,8 @@ package com.droiddeck.launcher.input -import android.accessibilityservice.AccessibilityService -import android.accessibilityservice.AccessibilityServiceInfo +import android.content.Context import android.content.Intent import android.content.pm.PackageManager -import android.graphics.Rect import android.hardware.display.DisplayManager import android.os.Build import android.os.Handler @@ -12,9 +10,9 @@ import android.os.HandlerThread import android.os.SystemClock import android.util.Log import android.view.Display -import android.view.accessibility.AccessibilityEvent import android.view.accessibility.AccessibilityWindowInfo import android.view.inputmethod.InputMethodManager +import com.droiddeck.shortcuts.Relay import java.util.concurrent.ConcurrentHashMap object BottomScreenGuests { @@ -45,7 +43,7 @@ object BottomScreenGuests { sdk >= 33 && DualScreen.yieldsBottom(model) } -class BottomScreenWatch(private val service: AccessibilityService) { +class BottomScreenWatch(private val service: Context) { private class Arrival(val pkg: String, val at: Long) private val thread = HandlerThread("bottom-screen").apply { start() } @@ -57,33 +55,22 @@ class BottomScreenWatch(private val service: AccessibilityService) { private var holders: Map = emptyMap() private var ownWindows: Map> = emptyMap() private val ownShownAt = mutableMapOf() - private val check = Runnable { evaluate() } fun start() { current = this - service.serviceInfo = service.serviceInfo?.apply { - eventTypes = eventTypes or AccessibilityEvent.TYPE_WINDOWS_CHANGED or AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED - flags = flags or AccessibilityServiceInfo.FLAG_RETRIEVE_INTERACTIVE_WINDOWS - } handler.post { homes = homePackages() keyboards = keyboardPackages() - evaluate() } } - fun onEvent(event: AccessibilityEvent) { - when (event.eventType) { - AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED -> { - val pkg = event.packageName?.toString() ?: return - if (event.displayId == Display.DEFAULT_DISPLAY || pkg == own || pkg == SYSTEM_UI) return - arrivals[event.displayId] = Arrival(pkg, event.eventTime) - } - AccessibilityEvent.TYPE_WINDOWS_CHANGED -> Unit - else -> return - } - handler.removeCallbacks(check) - handler.postDelayed(check, 150) + fun onArrival(displayId: Int, pkg: String, at: Long) { + if (displayId == Display.DEFAULT_DISPLAY || pkg == own || pkg == SYSTEM_UI) return + arrivals[displayId] = Arrival(pkg, at) + } + + fun onWindows(all: Map>) { + handler.post { evaluate(all) } } fun stop() { @@ -97,25 +84,22 @@ class BottomScreenWatch(private val service: AccessibilityService) { thread.quitSafely() } - private fun evaluate() { + private fun evaluate(all: Map>) { val seen = HashMap(arrivals) - val all = runCatching { service.windowsOnAllDisplays }.getOrNull() ?: return val displays = service.getSystemService(DisplayManager::class.java) ?: return val taken = mutableMapOf() val shown = mutableMapOf>() val now = SystemClock.uptimeMillis() - for (i in 0 until all.size()) { - val id = all.keyAt(i) + for ((id, list) in all) { if (id == Display.DEFAULT_DISPLAY) continue val display = displays.getDisplay(id)?.takeIf(DualScreen::builtIn) ?: continue - val windows = all.valueAt(i) + val windows = list .filter { !BottomScreenGuests.ignorable(it.type) && cover(it, display) >= BottomScreenGuests.MIN_COVER } .sortedByDescending { it.layer } - .map { it to packageOf(it) } - val ours = windows.filter { it.second == own }.map { it.first.id }.toSet() + val ours = windows.filter { it.pkg == own }.map { it.id }.toSet() if (!ownWindows[id].orEmpty().containsAll(ours)) ownShownAt[id] = now shown[id] = ours - val topPkg = windows.firstNotNullOfOrNull { it.second?.takeUnless { pkg -> pkg == own } } + val topPkg = windows.firstNotNullOfOrNull { it.pkg?.takeUnless { pkg -> pkg == own } } val arrival = seen[id]?.takeIf { BottomScreenGuests.current(it.at, ownShownAt[id]) } seen[id]?.takeIf { topPkg != null || arrival == null }?.let { arrivals.remove(id, it) } BottomScreenGuests.holder(topPkg, arrival?.pkg?.takeUnless { it in keyboards }, homes)?.let { taken[id] = it } @@ -127,15 +111,11 @@ class BottomScreenWatch(private val service: AccessibilityService) { DualScreen.setTaken(taken.keys) } - private fun cover(window: AccessibilityWindowInfo, display: Display): Float { - val bounds = Rect().also(window::getBoundsInScreen) + private fun cover(window: Relay.Window, display: Display): Float { val area = display.mode.physicalWidth.toFloat() * display.mode.physicalHeight - return if (area <= 0f) 0f else bounds.width().toFloat() * bounds.height() / area + return if (area <= 0f) 0f else window.bounds.width().toFloat() * window.bounds.height() / area } - private fun packageOf(window: AccessibilityWindowInfo): String? = - runCatching { window.getRoot(0)?.packageName?.toString() }.getOrNull() - private fun homePackages(): Set { val pm = service.packageManager return listOf(Intent.CATEGORY_HOME, Intent.CATEGORY_SECONDARY_HOME).flatMap { category -> @@ -154,6 +134,7 @@ class BottomScreenWatch(private val service: AccessibilityService) { private companion object { @Volatile var current: BottomScreenWatch? = null + const val TAG = "BottomScreen" const val SYSTEM_UI = "com.android.systemui" } diff --git a/app/src/main/java/com/droiddeck/launcher/input/FakeInputWriter.java b/app/src/main/java/com/droiddeck/launcher/input/FakeInputWriter.java index 8cbe135e7a..4675546d61 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/FakeInputWriter.java +++ b/app/src/main/java/com/droiddeck/launcher/input/FakeInputWriter.java @@ -82,6 +82,8 @@ public class FakeInputWriter { private static final int PAD_TYPE_OFFSET = IMU_OFFSET + 44; private static final int PAD_TYPE_SET = 0x80000000; private static final int LATENCY_OFFSET = IMU_OFFSET + 48; + private static final int REMOTE_IMU_MODE_OFFSET = IMU_OFFSET + 52; + private static final int REMOTE_IMU_PID_OFFSET = IMU_OFFSET + 56; public static final int LATENCY_CONTROLLER = 1; public static final int LATENCY_TOUCH = 2; private static volatile int latency = 0; @@ -231,6 +233,8 @@ public class FakeInputWriter { } data.putInt(IMU_OFFSET, 0); data.putInt(IMU_MODE_OFFSET, 0); + data.putInt(REMOTE_IMU_MODE_OFFSET, 0); + data.putInt(REMOTE_IMU_PID_OFFSET, 0); data.putLong(IMU_SEQ_OFFSET, 0L); for (int i = 0; i < 12; i++) { data.putShort(IMU_ACCEL_OFFSET + (i * 2), (short) 0); @@ -494,8 +498,11 @@ public class FakeInputWriter { if (ringSlot == null) return -1; synchronized (ringSlot) { ByteBuffer ring = ringSlot.data; - int value = ring == null ? 0 : ring.getInt(IMU_MODE_OFFSET); - return value < 0 ? value & 0xffff : -1; + if (ring == null) return 0; + int remote = ring.getInt(REMOTE_IMU_MODE_OFFSET); + int pid = ring.getInt(REMOTE_IMU_PID_OFFSET); + return ImuModes.combine(ring.getInt(IMU_MODE_OFFSET), remote, + remote < 0 && pid > 0 && new File("/proc/" + pid).exists()); } } diff --git a/app/src/main/java/com/droiddeck/launcher/input/HidMouseReport.kt b/app/src/main/java/com/droiddeck/launcher/input/HidMouseReport.kt new file mode 100644 index 0000000000..f562db1615 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/HidMouseReport.kt @@ -0,0 +1,158 @@ +package com.droiddeck.launcher.input + +/** Where a USB mouse's input report keeps its buttons, motion and wheel, as its HID report descriptor lays them out. */ +class HidMouseReport( + val reportId: Int, + private val buttons: List, + private val x: Field, + private val y: Field, + private val wheel: Field?, +) { + class Field(private val bit: Int, private val size: Int, private val signed: Boolean) { + fun read(report: ByteArray, length: Int, base: Int): Int { + var value = 0 + for (i in 0 until minOf(size, 32)) { + val at = base + bit + i + if (at / 8 >= length) break + if ((report[at / 8].toInt() shr (at % 8)) and 1 != 0) value = value or (1 shl i) + } + return if (signed && size in 1..31 && value and (1 shl (size - 1)) != 0) value - (1 shl size) else value + } + } + + /** [buttons] has bit 0 set for the first button. */ + data class State(val buttons: Int, val dx: Int, val dy: Int, val wheel: Int) + + /** Returns null for reports with another ID, such as a receiver's media keys. */ + fun decode(report: ByteArray, length: Int): State? { + val base = if (reportId == 0) 0 else { + if (length < 1 || (report[0].toInt() and 0xff) != reportId) return null + 8 + } + var pressed = 0 + buttons.forEachIndexed { i, field -> if (field != null && field.read(report, length, base) != 0) pressed = pressed or (1 shl i) } + return State(pressed, x.read(report, length, base), y.read(report, length, base), wheel?.read(report, length, base) ?: 0) + } + + companion object { + /** The report every boot mouse sends after SET_PROTOCOL(boot): three buttons, then X and Y as signed bytes. */ + val BOOT = HidMouseReport(0, List(3) { Field(it, 1, false) }, Field(8, 8, true), Field(16, 8, true), null) + + private const val BUTTON_PAGE = 0x09 + private const val MOUSE = 0x00010002 + private const val X = 0x00010030 + private const val Y = 0x00010031 + private const val WHEEL = 0x00010038 + private const val MAX_BUTTONS = 8 + private const val MAX_FIELD_BITS = 32 + private const val MAX_REPORT_COUNT = 4096 + + private class Global(var usagePage: Int = 0, var logicalMin: Int = 0, var reportSize: Int = 0, + var reportCount: Int = 0, var reportId: Int = 0) { + fun copy() = Global(usagePage, logicalMin, reportSize, reportCount, reportId) + } + + private class Placed(val reportId: Int, val field: Field) + + /** Returns null if [descriptor] has no mouse collection with X and Y in one report. */ + fun parse(descriptor: ByteArray): HidMouseReport? { + var global = Global() + val pushed = ArrayDeque() + val usages = mutableListOf() + var usageMin = -1 + var usageMax = -1 + val offsets = HashMap() + var depth = 0 + var mouseDepth = -1 + var mouseDone = false + val placed = HashMap() + + fun usage(index: Int): Int = when { + usages.isNotEmpty() -> usages.getOrElse(index) { usages.last() } + usageMin >= 0 && usageMax >= usageMin -> minOf(usageMin + index, usageMax) + else -> -1 + } + + var i = 0 + while (i < descriptor.size) { + val prefix = descriptor[i].toInt() and 0xff + if (prefix == 0xfe) { + if (i + 1 >= descriptor.size) break + i += 3 + (descriptor[i + 1].toInt() and 0xff) + continue + } + val size = intArrayOf(0, 1, 2, 4)[prefix and 3] + if (i + 1 + size > descriptor.size) break + var data = 0 + for (b in 0 until size) data = data or ((descriptor[i + 1 + b].toInt() and 0xff) shl (8 * b)) + val signedData = when (size) { + 1 -> data.toByte().toInt() + 2 -> data.toShort().toInt() + else -> data + } + val tag = prefix shr 4 + when ((prefix shr 2) and 3) { + 0 -> { + when (tag) { + 0x8 -> { + if (global.reportSize !in 0..MAX_FIELD_BITS || global.reportCount !in 0..MAX_REPORT_COUNT) return null + val start = offsets[global.reportId] ?: 0 + val isData = data and 1 == 0 + val isVariable = data and 2 != 0 + if (mouseDepth >= 0 && !mouseDone && isData && isVariable) { + for (n in 0 until global.reportCount) { + val u = usage(n) + if (u < 0) break + val field = Placed(global.reportId, Field(start + n * global.reportSize, global.reportSize, global.logicalMin < 0)) + val button = if (u ushr 16 == BUTTON_PAGE) u and 0xffff else 0 + when { + u == X || u == Y || u == WHEEL -> placed.putIfAbsent(u, field) + button in 1..MAX_BUTTONS -> placed.putIfAbsent(u, field) + } + } + } + offsets[global.reportId] = start + global.reportSize * global.reportCount + } + 0xa -> { + depth++ + if (mouseDepth < 0 && data == 1 && usage(0) == MOUSE) mouseDepth = depth + } + 0xc -> { + if (depth == mouseDepth) mouseDone = true + depth-- + } + } + usages.clear() + usageMin = -1 + usageMax = -1 + } + 1 -> when (tag) { + 0x0 -> global.usagePage = data + 0x1 -> global.logicalMin = signedData + 0x7 -> global.reportSize = data + 0x8 -> global.reportId = data + 0x9 -> global.reportCount = data + 0xa -> pushed.addLast(global.copy()) + 0xb -> global = pushed.removeLastOrNull() ?: global + } + 2 -> { + val full = if (size == 4) data else (global.usagePage shl 16) or data + when (tag) { + 0x0 -> usages += full + 0x1 -> usageMin = full + 0x2 -> usageMax = full + } + } + } + i += 1 + size + } + + val x = placed[X] ?: return null + val y = placed[Y]?.takeIf { it.reportId == x.reportId } ?: return null + val id = x.reportId + val buttons = (1..MAX_BUTTONS).map { n -> placed[(BUTTON_PAGE shl 16) or n]?.takeIf { it.reportId == id }?.field } + return HidMouseReport(id, buttons.dropLastWhile { it == null }, x.field, y.field, + placed[WHEEL]?.takeIf { it.reportId == id }?.field) + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/input/ImuModes.java b/app/src/main/java/com/droiddeck/launcher/input/ImuModes.java new file mode 100644 index 0000000000..1c208db274 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/ImuModes.java @@ -0,0 +1,14 @@ +package com.droiddeck.launcher.input; + +final class ImuModes { + private ImuModes() {} + + // Steam and its Remote Play client each keep their own mode word, with the top bit set once written. Motion is + // read while either process wants it, and a word that has not been set leaves the choice to the other one. + // -1 means neither has set a mode yet. + static int combine(int steam, int remote, boolean remoteRunning) { + boolean remoteSet = remote < 0 && remoteRunning; + if (steam >= 0 && !remoteSet) return -1; + return ((steam < 0 ? steam : 0) | (remoteSet ? remote : 0)) & 0xffff; + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/input/InputSpace.kt b/app/src/main/java/com/droiddeck/launcher/input/InputSpace.kt index 513962b811..90b5da1381 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/InputSpace.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/InputSpace.kt @@ -3,11 +3,16 @@ package com.droiddeck.launcher.input object InputSpace { const val WIDTH = 1920 const val HEIGHT = 1080 + const val FIXED_ONE = 256 fun x(position: Float, viewWidth: Int): Int = scale(position, viewWidth, WIDTH) fun y(position: Float, viewHeight: Int): Int = scale(position, viewHeight, HEIGHT) + fun fixedX(position: Float, viewWidth: Int): Int = scale(position, viewWidth, WIDTH * FIXED_ONE) + + fun fixedY(position: Float, viewHeight: Int): Int = scale(position, viewHeight, HEIGHT * FIXED_ONE) + private fun scale(position: Float, extent: Int, size: Int): Int = if (extent <= 0) 0 else (position / extent * size).toInt().coerceIn(0, size - 1) } diff --git a/app/src/main/java/com/droiddeck/launcher/input/MouseBackInput.kt b/app/src/main/java/com/droiddeck/launcher/input/MouseBackInput.kt index 9f8240640f..c220f5f68a 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/MouseBackInput.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/MouseBackInput.kt @@ -57,6 +57,16 @@ class MouseBackInput(private val sendRight: (Boolean) -> Unit, private val mouse !device.supportsSource(InputDevice.SOURCE_TOUCHSCREEN) } + /** A controller's own mouse interface (8BitDo Ultimate Mobile) is not a mouse the user right-clicks with. */ + fun externalMouse(devices: List): InputDevice? { + val controllers = devices.filterNotNull().filter { PadBridge.isFromController(it) } + return devices.filterNotNull().firstOrNull { mouse -> + isExternalMouse(mouse) && controllers.none { + it.vendorId != 0 && it.vendorId == mouse.vendorId && it.productId == mouse.productId + } + } + } + private val VIRTUAL_NAME = Regex("\\bvirtual\\b", RegexOption.IGNORE_CASE) fun declaresVirtual(name: String?): Boolean = name != null && VIRTUAL_NAME.containsMatchIn(name) diff --git a/app/src/main/java/com/droiddeck/launcher/input/MouseMenuHold.kt b/app/src/main/java/com/droiddeck/launcher/input/MouseMenuHold.kt new file mode 100644 index 0000000000..92bb16f65d --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/MouseMenuHold.kt @@ -0,0 +1,46 @@ +package com.droiddeck.launcher.input + +import kotlin.math.abs + +/** + * Holding the middle button still opens the session menu. While the session reads the mouse over USB, Android has + * no cursor, so this is how a mouse reaches the menu and, through it, the system again. + */ +class MouseMenuHold( + private val schedule: (Runnable, Long) -> Unit, + private val cancel: (Runnable) -> Unit, + private val onMenu: () -> Unit, +) { + private var holding = false + private var travel = 0 + private val fire = Runnable { + if (!holding) return@Runnable + holding = false + onMenu() + } + + fun onButton(index: Int, down: Boolean) { + if (index != MIDDLE) return + cancel(fire) + holding = down + travel = 0 + if (down) schedule(fire, HOLD_MS) + } + + fun onMove(dx: Int, dy: Int) { + if (!holding) return + travel += abs(dx) + abs(dy) + if (travel > SLOP) reset() + } + + fun reset() { + holding = false + cancel(fire) + } + + companion object { + const val MIDDLE = 2 + const val HOLD_MS = 2000L + const val SLOP = 48 + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/input/PenRouter.kt b/app/src/main/java/com/droiddeck/launcher/input/PenRouter.kt new file mode 100644 index 0000000000..622fab4dd8 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/PenRouter.kt @@ -0,0 +1,14 @@ +package com.droiddeck.launcher.input + +import com.droiddeck.launcher.session.SessionPrefs + +object PenRouter { + enum class Route { BLOCKED, PEN, RELATIVE, TOUCH } + + fun decide(uiBlocking: Boolean, mode: String, glasses: Boolean, programLock: Boolean): Route = when { + uiBlocking -> Route.BLOCKED + mode == SessionPrefs.PEN_TOUCH -> Route.TOUCH + glasses || programLock -> Route.RELATIVE + else -> Route.PEN + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/input/PenStream.kt b/app/src/main/java/com/droiddeck/launcher/input/PenStream.kt new file mode 100644 index 0000000000..67f90a679d --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/PenStream.kt @@ -0,0 +1,247 @@ +package com.droiddeck.launcher.input + +import android.graphics.RectF +import android.os.Build +import android.os.Handler +import android.os.Looper +import android.os.SystemClock +import android.view.InputDevice +import android.view.KeyEvent +import android.view.MotionEvent +import com.droiddeck.launcher.session.SessionPrefs + +class PenStream(private val sink: Sink) { + fun interface Sink { + fun sample(flags: Int, x: Int, y: Int) + } + + private val handler = Handler(Looper.getMainLooper()) + private val exitLater = Runnable { if (exitPending) leave() } + private val hoverWatchdog = Runnable { checkHover() } + private var watching = false + private var contact = false + private var barrel = 0 + private var keyDown = false + private var keyDevice = Int.MIN_VALUE + private var keyCode = 0 + private var exitPending = false + private var exitTime = 0L + private var deviceId = Int.MIN_VALUE + private var x = 0 + private var y = 0 + private var sampleTime = 0L + + var sideButton = SessionPrefs.PEN_BUTTON_RIGHT + + var inProximity = false + private set + + fun onMotion(event: MotionEvent, pointer: Int, area: RectF, width: Int, height: Int): Boolean { + val action = event.actionMasked + val time = event.eventTime + val own = isPenAction(event, pointer) + expire(time) + when (action) { + MotionEvent.ACTION_HOVER_ENTER, MotionEvent.ACTION_HOVER_MOVE -> { + continueAt(time) + contact = false + enter(event) + samples(event, pointer, area, width, height) + } + MotionEvent.ACTION_HOVER_EXIT -> if (inProximity && !exitPending && !contact) pendExit(time) + MotionEvent.ACTION_BUTTON_PRESS, MotionEvent.ACTION_BUTTON_RELEASE -> { + continueAt(time) + if (!inProximity) return true + barrel = event.buttonState + samples(event, pointer, area, width, height) + } + MotionEvent.ACTION_DOWN, MotionEvent.ACTION_POINTER_DOWN -> if (own) { + continueAt(time) + enter(event) + contact = true + samples(event, pointer, area, width, height) + } else if (contact) samples(event, pointer, area, width, height) + MotionEvent.ACTION_MOVE -> if (contact) { + barrel = event.buttonState + samples(event, pointer, area, width, height) + } + MotionEvent.ACTION_UP, MotionEvent.ACTION_POINTER_UP -> if (!own) { + if (contact) samples(event, pointer, area, width, height) + } else if (contact) { + if (event.flags and MotionEvent.FLAG_CANCELED != 0) cancel() + else { + barrel = event.buttonState + samples(event, pointer, area, width, height, lift = true) + pendExit(time) + } + } + MotionEvent.ACTION_CANCEL -> cancel() + else -> return false + } + return true + } + + fun onKey(event: KeyEvent): Boolean { + expire(event.eventTime) + val down = event.action == KeyEvent.ACTION_DOWN + val repeat = event.repeatCount > 0 + if (exitPending && !repeat) leave() + if (!inProximity || exitPending) { + if (!repeat && event.deviceId == keyDevice && event.keyCode == keyCode) keyDown = down + return true + } + if (down == keyDown) return true + val before = state() + keyDown = down + if (down) { + keyDevice = event.deviceId + keyCode = event.keyCode + } + if (state() == before) return true + emit(state()) + return true + } + + fun cancel(releaseKey: Boolean = false) { + if (releaseKey) keyDown = false + leave() + } + + fun holdsKey(event: KeyEvent): Boolean = keyDown && event.deviceId == keyDevice && event.keyCode == keyCode + + fun deviceRemoved(deviceId: Int) { + if (deviceId == this.deviceId) cancel() + if (!keyDown || deviceId != keyDevice) return + val before = state() + keyDown = false + if (inProximity && state() != before) emit(state()) + } + + private fun enter(event: MotionEvent) { + barrel = event.buttonState + if (inProximity) return + inProximity = true + deviceId = event.deviceId + } + + private fun continueAt(time: Long) { + if (!exitPending) return + if (time - exitTime > EXIT_GRACE_MS) { leave(); return } + exitPending = false + handler.removeCallbacks(exitLater) + } + + private fun pendExit(time: Long) { + exitPending = true + exitTime = time + handler.removeCallbacks(exitLater) + handler.postDelayed(exitLater, EXIT_GRACE_MS) + } + + private fun expire(time: Long) { + if (inProximity && !contact && time - sampleTime >= HOVER_TIMEOUT_MS) leave() + } + + private fun watchHover(delay: Long = HOVER_TIMEOUT_MS) { + if (watching || contact) return + watching = true + handler.postDelayed(hoverWatchdog, delay) + } + + private fun checkHover() { + watching = false + if (!inProximity || contact || exitPending) return + val silent = SystemClock.uptimeMillis() - sampleTime + if (silent >= HOVER_TIMEOUT_MS) leave() else watchHover(HOVER_TIMEOUT_MS - silent) + } + + private fun leave() { + if (!inProximity) return + emit(0) + handler.removeCallbacks(exitLater) + handler.removeCallbacks(hoverWatchdog) + watching = false + inProximity = false + contact = false + exitPending = false + barrel = 0 + } + + private fun samples(event: MotionEvent, pointer: Int, area: RectF, width: Int, height: Int, lift: Boolean = false) { + for (h in 0 until event.historySize) sample(event, pointer, h, area, width, height) + if (lift) contact = false + sample(event, pointer, -1, area, width, height) + } + + private fun sample(event: MotionEvent, pointer: Int, h: Int, area: RectF, width: Int, height: Int) { + x = InputSpace.fixedX(event.axis(MotionEvent.AXIS_X, pointer, h).coerceIn(area.left, area.right), width) + y = InputSpace.fixedY(event.axis(MotionEvent.AXIS_Y, pointer, h).coerceIn(area.top, area.bottom), height) + sampleTime = if (h < 0) event.eventTime else event.getHistoricalEventTime(h) + emit(state()) + watchHover() + } + + private fun emit(flags: Int) = sink.sample(flags, x, y) + + private fun state(): Int = + PEN_IN or (if (contact) PEN_TIP else 0) or buttonFlags(keyDown || barrel and MotionEvent.BUTTON_STYLUS_PRIMARY != 0, + barrel and MotionEvent.BUTTON_STYLUS_SECONDARY != 0, sideButton) + + private fun MotionEvent.axis(axis: Int, pointer: Int, h: Int): Float = + if (h < 0) getAxisValue(axis, pointer) else getHistoricalAxisValue(axis, pointer, h) + + companion object { + const val PEN_IN = 1 shl 0 + const val PEN_TIP = 1 shl 1 + const val PEN_RIGHT = 1 shl 2 + const val PEN_MIDDLE = 1 shl 3 + const val HOVER_TIMEOUT_MS = 2_000L + const val EXIT_GRACE_MS = 50L + + private val PEN_NAME = Regex("\\b(pen|stylus)", RegexOption.IGNORE_CASE) + + fun isPen(event: MotionEvent, index: Int): Boolean = when (event.getToolType(index)) { + MotionEvent.TOOL_TYPE_STYLUS, MotionEvent.TOOL_TYPE_ERASER -> true + MotionEvent.TOOL_TYPE_UNKNOWN -> event.isFromSource(InputDevice.SOURCE_STYLUS) + else -> false + } + + fun penConnected(): Boolean = + InputDevice.getDeviceIds().any { id -> InputDevice.getDevice(id)?.let { isPenDevice(it.sources) } == true } + + // Before Android 14 a touchscreen that declares ABS_MT_TOOL_TYPE reports SOURCE_STYLUS without any pen. + fun isPenDevice(sources: Int, sdk: Int = Build.VERSION.SDK_INT): Boolean = + sources and InputDevice.SOURCE_STYLUS == InputDevice.SOURCE_STYLUS && + (sources and InputDevice.SOURCE_TOUCHSCREEN != InputDevice.SOURCE_TOUCHSCREEN || sdk >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) + + fun penIndex(event: MotionEvent): Int { + for (index in 0 until event.pointerCount) if (isPen(event, index)) return index + return -1 + } + + fun isPenAction(event: MotionEvent, index: Int): Boolean = when (event.actionMasked) { + MotionEvent.ACTION_DOWN, MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> true + MotionEvent.ACTION_POINTER_DOWN, MotionEvent.ACTION_POINTER_UP -> event.actionIndex == index + else -> false + } + + fun isPenKey(event: KeyEvent): Boolean { + val device = event.device ?: return false + return isPenKeyboard(device.name, device.sources, Build.VERSION.SDK_INT < Build.VERSION_CODES.Q || device.isExternal, + device.keyboardType == InputDevice.KEYBOARD_TYPE_ALPHABETIC) + } + + fun isPenKeyboard(name: String?, sources: Int, external: Boolean, alphabetic: Boolean): Boolean = + external && !alphabetic && sources == InputDevice.SOURCE_KEYBOARD && name != null && PEN_NAME.containsMatchIn(name) + + fun buttonFlags(primary: Boolean, secondary: Boolean, sideButton: String): Int { + val first = when (sideButton) { + SessionPrefs.PEN_BUTTON_RIGHT -> PEN_RIGHT + SessionPrefs.PEN_BUTTON_MIDDLE -> PEN_MIDDLE + else -> 0 + } + val second = if (sideButton == SessionPrefs.PEN_BUTTON_RIGHT) PEN_MIDDLE else PEN_RIGHT + return (if (primary) first else 0) or (if (secondary) second else 0) + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/input/PointerSubset.kt b/app/src/main/java/com/droiddeck/launcher/input/PointerSubset.kt index d6d990ea8f..badf6ea95b 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/PointerSubset.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/PointerSubset.kt @@ -23,13 +23,20 @@ internal fun MotionEvent.pointerSubset(pointerIdBits: Int): MotionEvent? { } val properties = Array(indices.size) { MotionEvent.PointerProperties() } val coordinates = Array(indices.size) { MotionEvent.PointerCoords() } - indices.forEachIndexed { target, index -> - getPointerProperties(index, properties[target]) - getPointerCoords(index, coordinates[target]) + indices.forEachIndexed { target, index -> getPointerProperties(index, properties[target]) } + fun sample(position: Int): Array { + indices.forEachIndexed { target, index -> + if (position < historySize) getHistoricalPointerCoords(index, position, coordinates[target]) + else getPointerCoords(index, coordinates[target]) + } + return coordinates } - return MotionEvent.obtain( - downTime, eventTime, splitAction, indices.size, properties, coordinates, + fun time(position: Int) = if (position < historySize) getHistoricalEventTime(position) else eventTime + val split = MotionEvent.obtain( + downTime, time(0), splitAction, indices.size, properties, sample(0), metaState, buttonState, xPrecision, yPrecision, deviceId, edgeFlags, source, flags, ) + for (position in 1..historySize) split.addBatch(time(position), sample(position), metaState) + return split } diff --git a/app/src/main/java/com/droiddeck/launcher/input/HomeButtonService.kt b/app/src/main/java/com/droiddeck/launcher/input/ShortcutsRelay.kt similarity index 61% rename from app/src/main/java/com/droiddeck/launcher/input/HomeButtonService.kt rename to app/src/main/java/com/droiddeck/launcher/input/ShortcutsRelay.kt index 2f17ef1eae..6c24a7a472 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/HomeButtonService.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/ShortcutsRelay.kt @@ -1,14 +1,17 @@ package com.droiddeck.launcher.input -import android.accessibilityservice.AccessibilityService +import android.app.Service import android.content.Context import android.content.Intent import android.hardware.input.InputManager +import android.os.Binder import android.os.Handler +import android.os.IBinder import android.os.Looper +import android.os.Parcel import android.view.KeyEvent -import android.view.accessibility.AccessibilityEvent import com.droiddeck.launcher.HomeApp +import com.droiddeck.shortcuts.Relay object HomeButtonShortcuts { private var owner: Any? = null @@ -101,38 +104,78 @@ object SystemKeyCapture { } } -class HomeButtonService : AccessibilityService(), InputManager.InputDeviceListener { +class ShortcutsRelay : Service(), InputManager.InputDeviceListener { + private val main = Handler(Looper.getMainLooper()) + private val trusted = java.util.concurrent.ConcurrentHashMap.newKeySet() private var bottomScreen: BottomScreenWatch? = null - override fun onServiceConnected() { - getSystemService(InputManager::class.java).registerInputDeviceListener(this, Handler(Looper.getMainLooper())) - if (bottomScreen == null && BottomScreenGuests.supported()) bottomScreen = BottomScreenWatch(this).also { it.start() } + private val binder = object : Binder() { + override fun onTransact(code: Int, data: Parcel, reply: Parcel?, flags: Int): Boolean { + if (code !in Relay.CONFIG..Relay.WINDOWS) return super.onTransact(code, data, reply, flags) + data.enforceInterface(Relay.DESCRIPTOR) + if (!trusts(Binder.getCallingUid())) return false + when (code) { + Relay.CONFIG -> reply?.writeInt(if (bottomScreen != null) Relay.WANTS_WINDOWS else 0) + Relay.KEY -> reply?.writeInt(if (onMain(KeyEvent.CREATOR.createFromParcel(data))) 1 else 0) + Relay.INTERRUPT -> main.post { HomeButtonShortcuts.release() } + Relay.ARRIVAL -> bottomScreen?.onArrival(data.readInt(), data.readString() ?: return true, data.readLong()) + Relay.WINDOWS -> bottomScreen?.onWindows(Relay.decode(data.createByteArray() ?: return true)) + } + return true + } } - private fun stopBottomScreen() { - bottomScreen?.stop() - bottomScreen = null + private fun trusts(uid: Int): Boolean { + if (uid !in trusted) { + if (!packageManager.getPackagesForUid(uid).orEmpty().contains(Relay.PACKAGE)) return false + trusted += uid + } + return com.droiddeck.launcher.core.SteamIntegration.shortcutsEnabled(this) + } + + private fun onMain(event: KeyEvent): Boolean { + // A key the companion already gave up on must not run later and leave a press without its release. + val claimed = java.util.concurrent.atomic.AtomicBoolean(false) + val task = java.util.concurrent.FutureTask { + claimed.compareAndSet(false, true) && + (SystemKeyCapture.onKeyEvent(event) || HomeButtonShortcuts.onKeyEvent(this, event)) + } + main.postAtFrontOfQueue(task) + return try { + task.get(KEY_TIMEOUT_MS, java.util.concurrent.TimeUnit.MILLISECONDS) + } catch (e: java.util.concurrent.TimeoutException) { + if (claimed.compareAndSet(false, true)) false else runCatching { task.get() }.getOrDefault(false) + } catch (e: Exception) { + false + } + } + + override fun onCreate() { + super.onCreate() + getSystemService(InputManager::class.java).registerInputDeviceListener(this, main) + if (BottomScreenGuests.supported()) bottomScreen = BottomScreenWatch(this).also { it.start() } + } + + override fun onBind(intent: Intent?): IBinder = binder + + override fun onUnbind(intent: Intent?): Boolean { + HomeButtonShortcuts.release() + return super.onUnbind(intent) } - override fun onKeyEvent(event: KeyEvent) = - SystemKeyCapture.onKeyEvent(event) || HomeButtonShortcuts.onKeyEvent(this, event) - override fun onAccessibilityEvent(event: AccessibilityEvent?) { event?.let { bottomScreen?.onEvent(it) } } - override fun onInterrupt() { HomeButtonShortcuts.release() } override fun onInputDeviceAdded(deviceId: Int) {} override fun onInputDeviceChanged(deviceId: Int) {} override fun onInputDeviceRemoved(deviceId: Int) { HomeButtonShortcuts.onDeviceRemoved(deviceId) } - override fun onUnbind(intent: Intent?): Boolean { - HomeButtonShortcuts.release() - stopBottomScreen() - com.droiddeck.launcher.core.SteamIntegration.syncShortcutsListing(this) - return super.onUnbind(intent) - } - override fun onDestroy() { HomeButtonShortcuts.release() - stopBottomScreen() + bottomScreen?.stop() + bottomScreen = null getSystemService(InputManager::class.java).unregisterInputDeviceListener(this) super.onDestroy() } + + private companion object { + const val KEY_TIMEOUT_MS = 200L + } } diff --git a/app/src/main/java/com/droiddeck/launcher/input/UsbMouse.kt b/app/src/main/java/com/droiddeck/launcher/input/UsbMouse.kt new file mode 100644 index 0000000000..ffc2960c9a --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/UsbMouse.kt @@ -0,0 +1,262 @@ +package com.droiddeck.launcher.input + +import android.app.PendingIntent +import android.content.BroadcastReceiver +import android.content.Context +import android.content.Intent +import android.content.IntentFilter +import android.hardware.usb.UsbConstants +import android.hardware.usb.UsbDevice +import android.hardware.usb.UsbDeviceConnection +import android.hardware.usb.UsbEndpoint +import android.hardware.usb.UsbInterface +import android.hardware.usb.UsbManager +import android.os.Build +import android.os.Handler +import android.os.Looper +import android.os.SystemClock +import android.util.Log +import android.view.InputDevice + +/** + * Reads a USB mouse from its HID interface, detaching it from Android meanwhile. Android only grants pointer + * capture on the focused display, so an app shown elsewhere, as in REDMAGIC's cast mode, gets a cursor that + * stops at the screen edge. + */ +class UsbMouse(private val context: Context, private val listener: Listener) { + interface Listener { + fun onMove(dx: Int, dy: Int) + fun onButton(index: Int, down: Boolean) + fun onWheel(steps: Int) + fun onChanged() + /** The mouse stopped responding while read here, so buttons held then never got their releases. */ + fun onLost() + } + + private val usb by lazy { context.getSystemService(Context.USB_SERVICE) as UsbManager } + private val main = Handler(Looper.getMainLooper()) + private val permissionAction by lazy { context.packageName + ".USB_MOUSE_PERMISSION" } + private val asked = mutableSetOf() + private val failed = mutableSetOf() + private var receiverRegistered = false + @Volatile private var grab: Grab? = null + private var lastReader: Thread? = null + + val active: Boolean get() = grab != null + + private val receiver = object : BroadcastReceiver() { + override fun onReceive(context: Context, intent: Intent) { + val granted = intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false) + Log.i(TAG, "USB mouse access ${if (granted) "granted" else "denied"}") + if (granted) listener.onChanged() + } + } + + /** + * Returns whether the mouse is now read here, setting it up on the reader thread; asks for access once per + * plugged-in mouse. A mouse that fails setup after being claimed isn't tried again until it is replugged, since + * releasing it re-adds Android's mouse, which would start another attempt. + */ + fun grab(): Boolean { + if (grab != null) return true + val (device, mouse) = findMouse() ?: return false + if (device.deviceName in failed) return false + if (!usb.hasPermission(device)) { + if (asked.add(device.deviceName)) askPermission(device) + return false + } + val endpoint = (0 until mouse.endpointCount).map(mouse::getEndpoint).firstOrNull { + it.direction == UsbConstants.USB_DIR_IN && it.type == UsbConstants.USB_ENDPOINT_XFER_INT + } ?: return false + grab = Grab(device, mouse, endpoint, lastReader).also { + lastReader = it.thread + it.thread.start() + } + return true + } + + /** Hands the mouse back to Android. */ + fun release() { + val current = grab ?: return + grab = null + current.cancel() + } + + fun close() { + release() + if (receiverRegistered) runCatching { context.unregisterReceiver(receiver) } + receiverRegistered = false + } + + private fun findMouse(): Pair? { + val androidMice = InputDevice.getDeviceIds().asList().mapNotNull { InputDevice.getDevice(it) } + .filter { !it.isVirtual && it.supportsSource(InputDevice.SOURCE_MOUSE) } + .map { it.vendorId to it.productId }.toSet() + return usb.deviceList.values.filter { (it.vendorId to it.productId) in androidMice }.firstNotNullOfOrNull { device -> + (0 until device.interfaceCount).map(device::getInterface).firstOrNull(::isBootMouse)?.let { device to it } + } + } + + private fun askPermission(device: UsbDevice) { + if (!receiverRegistered) { + val filter = IntentFilter(permissionAction) + if (Build.VERSION.SDK_INT >= 33) context.registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED) + else context.registerReceiver(receiver, filter) + receiverRegistered = true + } + val flags = if (Build.VERSION.SDK_INT >= 31) PendingIntent.FLAG_MUTABLE else 0 + val intent = PendingIntent.getBroadcast(context, 0, Intent(permissionAction).setPackage(context.packageName), flags) + runCatching { usb.requestPermission(device, intent) }.onFailure { + asked.remove(device.deviceName) + Log.w(TAG, "requestPermission", it) + } + } + + private inner class Grab( + private val device: UsbDevice, + private val mouse: UsbInterface, + private val endpoint: UsbEndpoint, + private val previous: Thread?, + ) { + @Volatile private var running = true + private val claimLock = Any() + val thread = Thread(::run, "usb-mouse") + + /** Once this returns, the reader either never claims the interface or sees the cancellation after claiming. */ + fun cancel() = synchronized(claimLock) { running = false } + + // The reader owns the connection: closing it while a transfer is pending would free it under the transfer. + // A previous reader may still hold the interface, which would make this claim fail. + private fun run() { + runCatching { previous?.join() } + val connection = if (running) usb.openDevice(device) else null + if (connection == null) { + main.post { ended(markFailed = false) } + return + } + var claimed = false + var boot = false + try { + claimed = synchronized(claimLock) { running && connection.claimInterface(mouse, true) } + if (!claimed) { + main.post { ended(markFailed = false) } + return + } + if (!running) return + val format = setUp(connection) + if (format == null) { + main.post { ended(markFailed = true) } + return + } + boot = format === HidMouseReport.BOOT + if (!running) return + Log.i(TAG, String.format(java.util.Locale.ROOT, "reading USB mouse %04x:%04x \"%s\" directly (%s)", + device.vendorId, device.productId, device.productName, if (boot) "boot protocol" else "report ${format.reportId}")) + read(connection, format) + } finally { + if (claimed) { + if (boot) connection.controlTransfer(0x21, SET_PROTOCOL, HID_REPORT_PROTOCOL, mouse.id, null, 0, CONTROL_TIMEOUT_MS) + connection.releaseInterface(mouse) + } + connection.close() + } + } + + /** HID 1.11 7.2.6: a host must not assume the protocol a device is in, so it is set either way. */ + private fun setUp(connection: UsbDeviceConnection): HidMouseReport? { + val descriptor = ByteArray(1024) + val length = connection.controlTransfer(0x81, GET_DESCRIPTOR, HID_REPORT_DESCRIPTOR shl 8, mouse.id, + descriptor, descriptor.size, CONTROL_TIMEOUT_MS) + val parsed = if (length > 0) HidMouseReport.parse(descriptor.copyOf(length)) else null + if (parsed != null && running && + connection.controlTransfer(0x21, SET_PROTOCOL, HID_REPORT_PROTOCOL, mouse.id, null, 0, CONTROL_TIMEOUT_MS) >= 0) return parsed + val boot = running && + connection.controlTransfer(0x21, SET_PROTOCOL, HID_BOOT_PROTOCOL, mouse.id, null, 0, CONTROL_TIMEOUT_MS) >= 0 + return HidMouseReport.BOOT.takeIf { boot } + } + + private fun read(connection: UsbDeviceConnection, format: HidMouseReport) { + val report = ByteArray(maxOf(endpoint.maxPacketSize, 8)) + var buttons = 0 + var failures = 0 + while (running) { + val started = SystemClock.uptimeMillis() + val length = connection.bulkTransfer(endpoint, report, report.size, READ_TIMEOUT_MS) + if (length <= 0) { + if (SystemClock.uptimeMillis() - started < READ_TIMEOUT_MS / 2 && ++failures >= MAX_FAILURES) { + main.post { lost() } + return + } + continue + } + failures = 0 + val state = format.decode(report, length) ?: continue + val changed = buttons xor state.buttons + buttons = state.buttons + main.post { deliver(state, changed) } + } + } + + private fun ended(markFailed: Boolean) { + if (grab !== this) return + if (markFailed) failed += device.deviceName + Log.i(TAG, "USB mouse \"${device.productName}\" could not be set up") + grab = null + } + + private fun deliver(state: HidMouseReport.State, changed: Int) { + if (grab !== this) return + if (state.dx != 0 || state.dy != 0) listener.onMove(state.dx, state.dy) + for (i in 0 until BUTTONS) if (changed and (1 shl i) != 0) listener.onButton(i, state.buttons and (1 shl i) != 0) + if (state.wheel != 0) listener.onWheel(state.wheel) + } + + private fun lost() { + if (grab !== this) return + failed += device.deviceName + Log.i(TAG, "USB mouse stopped responding") + grab = null + listener.onLost() + } + } + + companion object { + private const val TAG = "UsbMouse" + private const val GET_DESCRIPTOR = 0x06 + private const val SET_PROTOCOL = 0x0b + private const val HID_BOOT_PROTOCOL = 0 + private const val HID_REPORT_PROTOCOL = 1 + private const val HID_REPORT_DESCRIPTOR = 0x22 + private const val SUBCLASS_BOOT = 1 + private const val PROTOCOL_MOUSE = 2 + private const val CONTROL_TIMEOUT_MS = 1000 + private const val READ_TIMEOUT_MS = 100 + private const val MAX_FAILURES = 5 + private const val BUTTONS = 5 + + private fun isBootMouse(iface: UsbInterface) = iface.interfaceClass == UsbConstants.USB_CLASS_HID && + iface.interfaceSubclass == SUBCLASS_BOOT && iface.interfaceProtocol == PROTOCOL_MOUSE + + /** + * A process killed while reading a mouse leaves it with no driver until it is replugged. Claiming without + * force only succeeds when no driver has the interface, and releasing it reattaches Android's. + */ + fun returnLeftover(context: Context) { + Thread({ + runCatching { + val usb = context.getSystemService(Context.USB_SERVICE) as UsbManager + for (device in usb.deviceList.values) { + if (!usb.hasPermission(device)) continue + val mouse = (0 until device.interfaceCount).map(device::getInterface).firstOrNull(::isBootMouse) ?: continue + val connection = usb.openDevice(device) ?: continue + if (connection.claimInterface(mouse, false)) { + connection.releaseInterface(mouse) + Log.i(TAG, "returned USB mouse \"${device.productName}\" to Android") + } + connection.close() + } + }.onFailure { Log.w(TAG, "returning a USB mouse to Android failed", it) } + }, "usb-mouse-return").start() + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/session/BottomDesktop.kt b/app/src/main/java/com/droiddeck/launcher/session/BottomDesktop.kt index 10d031715b..32225c3f95 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/BottomDesktop.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/BottomDesktop.kt @@ -194,7 +194,7 @@ object BottomDesktop { send(target, Message.obtain(null, Comp.MSG_POINTER, x, y)) } - /** Button (3), wheel (4) and smooth-scroll (12) input, as `WaylandCompositor.nativeSendSceneInput` takes it. */ + /** Button, wheel and finger-scroll input, using the `WaylandCompositor.SCENE_*` types `nativeSendSceneInput` takes. */ fun sendScene(type: Int, a: Int, b: Int = 0) { val target = service ?: return send(target, Message.obtain(null, Comp.MSG_SCENE, type, a).apply { diff --git a/app/src/main/java/com/droiddeck/launcher/session/GameThreadHints.kt b/app/src/main/java/com/droiddeck/launcher/session/GameThreadHints.kt index 3c2c5098b7..0f2b2273f8 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/GameThreadHints.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/GameThreadHints.kt @@ -8,6 +8,7 @@ import android.os.Process import android.system.Os import android.system.OsConstants import android.util.Log +import com.droiddeck.launcher.gpu.SocNames import com.droiddeck.launcher.wayland.WaylandCompositor import java.io.File import kotlin.math.abs @@ -26,13 +27,14 @@ object GameThreadHints { private const val PACE_TOLERANCE = 0.08 private val NOT_GAMES = setOf("steam", "steamwebhelper") + private val SOCS = setOf("CQ8725S", "SM8750") private var worker: Thread? = null @Synchronized fun start(context: Context): String { if (!SessionPrefs.gameThreadHints(context)) return "game thread hints: off" - if (Build.VERSION.SDK_INT < 31 || Build.SOC_MODEL != "CQ8725S") return "game thread hints: Odin 3 only" + if (Build.VERSION.SDK_INT < 31 || !supported(Build.SOC_MODEL)) return "game thread hints: Snapdragon 8 Elite only" val hm = context.getSystemService(PerformanceHintManager::class.java) ?: return "game thread hints: no PerformanceHintManager" val pm = context.getSystemService(PowerManager::class.java) @@ -99,6 +101,8 @@ object GameThreadHints { } } + internal fun supported(soc: String): Boolean = SocNames.normalizedModel(soc) in SOCS + internal fun holdsPace(fps: Double, refreshHz: Double): Boolean = fps >= 10 && refreshHz > 0 && (1..4).any { k -> abs(fps - refreshHz / k) < PACE_TOLERANCE * refreshHz / k } diff --git a/app/src/main/java/com/droiddeck/launcher/session/GraphicsReport.kt b/app/src/main/java/com/droiddeck/launcher/session/GraphicsReport.kt index 4d1ee473e4..8caa1e6f8e 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/GraphicsReport.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/GraphicsReport.kt @@ -60,17 +60,19 @@ object GraphicsReport { appendLine("-- path") appendLine("path: " + path(context)) appendLine("driver mode: " + SessionPrefs.gpuDriverMode(context)) - appendLine("display driver (compositor): " + SessionPrefs.androidDriver(context).ifEmpty { - if (DeviceSupport.adreno()) "(auto: bundled Turnip)" else "(auto: the phone's own Vulkan driver, ${SystemVulkanDriver.hal() ?: "vendor HAL"})" - }) val display = SessionPrefs.androidDriver(context) + val shown = com.droiddeck.launcher.gpu.TurnipDriver(context).effectiveId() + appendLine("display driver (compositor): " + + (if (shown == "system") "the phone's own Vulkan driver, ${SystemVulkanDriver.hal() ?: "vendor HAL"}" else shown) + + if (display.isEmpty()) " (auto)" else if (display != shown) " (picked $display, not used)" else "") appendLine("display driver chosen by: " + when { display.isEmpty() -> "auto (or a pair on a non-Adreno GPU: the phone's own driver)" DriverBundle.containing(context, display, false) != null -> "pair (its display half)" else -> "user (picked on its own)" }) val linux = SessionPrefs.linuxDriver(context) - appendLine("runtime driver: " + linux.ifEmpty { "(runtime default)" }) + appendLine("runtime driver: " + (com.droiddeck.launcher.gpu.DeviceInfo.hostRoute(context) + ?.let { "$it (picked ${linux.ifEmpty { "runtime default" }}, not used)" } ?: linux.ifEmpty { "(runtime default)" })) if (linux.isNotEmpty()) { val dir = com.droiddeck.launcher.gpu.LinuxVulkanDriverManager(context).getDriverDir(linux) appendLine("runtime driver dir: ${dir.path} (" + (dir.listFiles()?.filter { it.name.endsWith(".so") }?.joinToString { it.name } ?: "missing") + ")") @@ -161,8 +163,8 @@ object GraphicsReport { private fun read(path: String): String? = FileUtils.readString(File(path))?.trim()?.takeIf { it.isNotEmpty() } /** The compositor's driver lines from the app's own log. */ - private val COMPOSITOR = Regex( - """vk_present|waylandcomp|vk_loader|compositor|vkCreateDevice|extension|adrenotools|TurnipDriver|""" + + internal val COMPOSITOR = Regex( + """vk_present|waylandcomp|vk_loader|compositor|vkCreateDevice|extension|adrenotools|hook_impl|TurnipDriver|""" + """graphics driver|display driver|DD_PRESENT_FAULT|SystemVulkan|vkbridge|VkBridge|mali_gralloc|panvk|PanVK|radv|MESA|native buffer|first frame|present|""" + """lsfg|FrameGen|device gates|AAudio|directaudio|pulse|gralloc|dma.?buf|modifier|import""", RegexOption.IGNORE_CASE, diff --git a/app/src/main/java/com/droiddeck/launcher/session/RumbleComponent.kt b/app/src/main/java/com/droiddeck/launcher/session/RumbleComponent.kt index 39d99bfa6c..677d16511d 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/RumbleComponent.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/RumbleComponent.kt @@ -19,6 +19,7 @@ import com.droiddeck.launcher.input.ControllerPrefs import com.droiddeck.launcher.input.JoyCon import com.droiddeck.launcher.input.PadBridge import java.io.DataInputStream +import java.io.File import kotlin.math.max class RumbleComponent : SessionPart() { @@ -39,6 +40,10 @@ class RumbleComponent : SessionPart() { internal var controllerMotors: (Int) -> Motors? = ::lookupController internal var motorLooper: Looper? = null + internal var processStart: (Int) -> String? = ::readProcessStart + internal var gameRunning: () -> Boolean = { SteamGameProcess.running() } + private var gameCheckedAt = Long.MIN_VALUE + private var gameLastSeen = false @Synchronized private fun refreshEnabled() { enabled = app()?.let { ControllerPrefs.rumbleEnabled(it) } == true @@ -66,7 +71,9 @@ class RumbleComponent : SessionPart() { try { val bytes = ByteArray(8) DataInputStream(client.inputStream).readFully(bytes) - buzz(u16(bytes, 0), u16(bytes, 2), u16(bytes, 4), u16(bytes, 6)) + val peer = runCatching { client.peerCredentials }.getOrNull() + buzz(u16(bytes, 0), u16(bytes, 2), u16(bytes, 4), u16(bytes, 6), peer?.pid ?: 0, + peer?.uid == android.os.Process.myUid()) } catch (e: Exception) { } finally { try { client.close() } catch (e: Exception) { } @@ -94,7 +101,9 @@ class RumbleComponent : SessionPart() { private fun u16(b: ByteArray, at: Int): Int = (b[at].toInt() and 0xFF) or ((b[at + 1].toInt() and 0xFF) shl 8) - @Synchronized private fun buzz(strong: Int, weak: Int, ms: Int, slot: Int) { + private fun buzz(strong: Int, weak: Int, ms: Int, slot: Int) = buzz(strong, weak, ms, slot, 0, false) + + @Synchronized private fun buzz(strong: Int, weak: Int, ms: Int, slot: Int, sender: Int, ownUser: Boolean) { if (!enabled || quiet) return val target = target(slot) val previous = playing[slot] @@ -105,10 +114,19 @@ class RumbleComponent : SessionPart() { target?.let { Log.i(TAG, "rumble: slot $slot playing on ${it.name}") } } if (target == null) return - if ((strong == 0 && weak == 0) || ms == 0) { target.cancel(); forget(slot); return } + if ((strong == 0 && weak == 0) || ms == 0) { + val from = effects[slot]?.from ?: 0 + if (sender > 0 && from > 0 && from != sender) return + target.cancel() + forget(slot) + return + } val handler = handler ?: return val effect = effects.getOrPut(slot) { Effect(slot) } + val held = effect.hold effect.want(strong, weak, ms) + effect.from = sender + if (effect.hold && (!held || effect.owner != sender)) effect.claim(sender, ownUser) val now = SystemClock.uptimeMillis() if (effect.playing(now)) return handler.removeCallbacks(effect) @@ -116,19 +134,37 @@ class RumbleComponent : SessionPart() { if (wait > 0) handler.postDelayed(effect, wait) else play(effect) } - @Synchronized private fun play(effect: Effect) { + @Synchronized private fun play(effect: Effect, keepalive: Boolean = false) { val target = playing[effect.slot] if (target == null || effects[effect.slot] !== effect) return + if (keepalive && effect.hold && effect.armed) effect.orphaned()?.let { why -> + Log.i(TAG, "rumble: slot ${effect.slot} stopped, $why") + target.cancel() + forget(effect.slot) + return + } val duration = if (effect.hold) HOLD_EFFECT_MS else effect.ms.toLong().coerceIn(1L, 5000L) try { target.play(effect.strong, effect.weak, duration) effect.played(SystemClock.uptimeMillis(), duration) - if (effect.hold) handler?.postDelayed(effect, KEEPALIVE_MS) + if (effect.hold) { + effect.armed = true + handler?.postDelayed(effect, KEEPALIVE_MS) + } } catch (e: Exception) { Log.w(TAG, "rumble: ${target.name}: $e") } } + private fun gameRecently(): Boolean { + val now = SystemClock.uptimeMillis() + if (!gameLastSeen || now - gameCheckedAt >= GAME_CHECK_MS) { + gameLastSeen = gameRunning() + gameCheckedAt = now + } + return gameLastSeen + } + private fun forget(slot: Int) { effects.remove(slot)?.let { handler?.removeCallbacks(it) } } @@ -170,8 +206,32 @@ class RumbleComponent : SessionPart() { private var playedWeak = 0 private var playedMs = 0 private var until = 0L + var owner = 0 + var from = 0 + private var ownerSeen = false + private var ownerStart: String? = null + private var duringGame = false + var armed = false val hold get() = ms == HOLD_MS + fun claim(sender: Int, ownUser: Boolean) { + owner = sender + val start = if (sender > 0) processStart(sender) else null + ownerSeen = sender > 0 && (start != null || ownUser) + ownerStart = start?.takeIf { it != UNKNOWN_START } + duringGame = gameRecently() + armed = false + } + + fun orphaned(): String? { + if (ownerSeen) { + val start = processStart(owner) + if (start == null || (ownerStart != null && start != UNKNOWN_START && start != ownerStart)) + return "process $owner that started it is gone" + } + return if (duringGame && !gameRunning()) "the game it started in has exited" else null + } + fun want(strong: Int, weak: Int, ms: Int) { this.strong = strong; this.weak = weak; this.ms = ms } fun playing(now: Long) = playedMs != 0 && playedStrong == strong && playedWeak == weak && playedMs == ms && @@ -185,7 +245,7 @@ class RumbleComponent : SessionPart() { until = now + duration } - override fun run() = play(this) + override fun run() = play(this, keepalive = true) } internal interface Motors { @@ -256,6 +316,7 @@ class RumbleComponent : SessionPart() { const val HOLD_MS = 0xFFFF const val HOLD_EFFECT_MS = 2000L const val KEEPALIVE_MS = 1500L + const val GAME_CHECK_MS = 1000L private fun oneShot(vibrator: Vibrator, strength: Int, ms: Long): VibrationEffect { val amplitude = if (vibrator.hasAmplitudeControl()) (strength * 255L / 65535L).toInt().coerceIn(1, 255) @@ -263,6 +324,13 @@ class RumbleComponent : SessionPart() { return VibrationEffect.createOneShot(ms, amplitude) } + const val UNKNOWN_START = "?" + + internal fun readProcessStart(pid: Int): String? = runCatching { + val stat = File("/proc/$pid/stat").readText() + stat.substring(stat.lastIndexOf(')') + 2).split(' ')[19] + }.getOrElse { if (File("/proc/$pid").exists()) UNKNOWN_START else null } + private fun lookupController(id: Int): Motors? { val device = InputDevice.getDevice(id) ?: return null val name = "\"${device.name}\"" diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt index 96c556f174..708e43a16a 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -73,6 +73,7 @@ object SessionFiles { "rockstar/helpers/Launcher32.exe" to "usr/local/lib/droiddeck-rockstar/Launcher32.exe", "rockstar/helpers/Launcher64.exe" to "usr/local/lib/droiddeck-rockstar/Launcher64.exe", "usr/local/bin/droiddeck-game-env" to "usr/local/bin/droiddeck-game-env", + "usr/local/bin/droiddeck-game-debug" to "usr/local/bin/droiddeck-game-debug", "usr/local/bin/droiddeck-game-gpu" to "usr/local/bin/droiddeck-game-gpu", "usr/local/bin/droiddeck-diagnostic-inventory" to "usr/local/bin/droiddeck-diagnostic-inventory", "usr/local/bin/droiddeck-wincomponents" to "usr/local/bin/droiddeck-wincomponents", diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPaths.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPaths.kt index 524271d4a9..69cb7d4fae 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPaths.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPaths.kt @@ -23,6 +23,9 @@ object SessionPaths { @Volatile private var ended: File? = null + @Volatile + private var startedAt = 0L + @Synchronized fun beginOrCurrent(context: Context, label: String? = null): File { dir?.let { if (it.isDirectory) return it } @@ -38,6 +41,7 @@ object SessionPaths { var made = File(parent, "$day-${"%02d".format(Locale.US, number)}-$what") while (made.exists()) made = File(parent, "$day-${"%02d".format(Locale.US, ++number)}-$what") EnhancedDiagnostics.clearRecordFor(context, made) + startedAt = System.currentTimeMillis() if (!made.isDirectory && !made.mkdirs()) Log.e(TAG, "could not create $made") dir = made if (enhanced && !EnhancedDiagnostics.consumeInto(context, made)) { @@ -49,6 +53,8 @@ object SessionPaths { fun current(): File? = dir + fun startedAt(folder: File): Long = if (dir == folder) startedAt else 0L + fun currentSessionLogsRetained(context: Context): Boolean = dir?.let { it.parentFile == SessionFiles.logDirectory(context) } ?: true diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index e6a8befb90..8fe4461b13 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -13,6 +13,8 @@ import com.droiddeck.launcher.gpu.TurnipDriver import org.json.JSONObject import java.io.File +private const val SCREEN_EFFECTS_PROFILE_UPSCALER_KEY = "upscaler" + object SessionPrefs { data class GameTextureFiltering(val anisotropy: Int? = null, val lodBias: String? = null) @@ -514,6 +516,38 @@ object SessionPrefs { prefs(context).edit().putString("touch", mode).apply() } + const val PEN_MOUSE = "mouse" + const val PEN_TOUCH = "touch" + const val PEN_BUTTON_RIGHT = "right" + const val PEN_BUTTON_MIDDLE = "middle" + const val PEN_BUTTON_OFF = "off" + + data class Pen(val mode: String = PEN_MOUSE, val button: String = PEN_BUTTON_RIGHT) + + private val PEN_SETTINGS = mapOf( + "pen" to setOf(PEN_MOUSE, PEN_TOUCH), + "penButton" to setOf(PEN_BUTTON_RIGHT, PEN_BUTTON_MIDDLE, PEN_BUTTON_OFF), + ) + + private fun penSetting(context: Context, key: String, default: String): String = + prefs(context).getString(key, default)?.takeIf { it in PEN_SETTINGS.getValue(key) } ?: default + + fun setPenSetting(context: Context, key: String, value: String) { + require(value in PEN_SETTINGS.getValue(key)) + prefs(context).edit().putString(key, value).apply() + } + + fun penMode(context: Context): String = penSetting(context, "pen", PEN_MOUSE) + fun penButton(context: Context): String = penSetting(context, "penButton", PEN_BUTTON_RIGHT) + + fun pen(context: Context): Pen = Pen(penMode(context), penButton(context)) + + fun penSeen(context: Context): Boolean = prefs(context).getBoolean("penSeen", false) + + fun setPenSeen(context: Context) { + if (!penSeen(context)) prefs(context).edit().putBoolean("penSeen", true).apply() + } + const val SHAPE_AUTO = "auto" const val SHAPE_WIDE = "16:9" const val SHAPE_EXACT = "exact" @@ -780,6 +814,12 @@ object SessionPrefs { prefs(context).edit().putBoolean("zramClient", on).apply() } + fun zramIdle(context: Context): Boolean = prefs(context).getBoolean("zramIdle", true) + + fun setZramIdle(context: Context, on: Boolean) { + prefs(context).edit().putBoolean("zramIdle", on).apply() + } + fun vramCapMb(context: Context): Int = prefs(context).getInt("vramCapMb", 0).coerceAtLeast(0) fun setVramCapMb(context: Context, mb: Int) { @@ -873,8 +913,12 @@ object SessionPrefs { @JvmStatic fun vkBridge(context: Context): Boolean = prefs(context).getBoolean("vkBridge", com.droiddeck.launcher.core.DeviceSupport.mali()) + fun vkBridgeExplicit(context: Context): Boolean = prefs(context).contains("vkBridge") + fun venus(context: Context): Boolean = prefs(context).getBoolean("venus", false) + fun venusExplicit(context: Context): Boolean = prefs(context).contains("venus") + fun hostVulkanApi(context: Context): String = prefs(context).getString("hostVulkanApi", "").orEmpty() fun setHostVulkanApi(context: Context, api: String) { @@ -1374,6 +1418,13 @@ object SessionPrefs { prefs(context).edit().putInt("gradientPrimary", primary).putInt("gradientSecondary", secondary).apply() } + fun trueBlackHighlight(context: Context): Int = + prefs(context).getInt("trueBlackHighlight", com.droiddeck.launcher.ui.Themes.DEFAULT_HIGHLIGHT) + + fun setTrueBlackHighlight(context: Context, highlight: Int) { + prefs(context).edit().putInt("trueBlackHighlight", highlight).apply() + } + private fun customResolution(context: Context, mode: String): Pair? = parseResolution(prefs(context).getString("customRes.$mode", null)) @@ -1443,15 +1494,136 @@ object SessionPrefs { } + private const val SCREEN_EFFECTS_PROFILES_KEY = "screenEffects.profiles" + const val SCREEN_EFFECTS_ACTIVE_PROFILE_KEY = "screenEffects.activeProfile" + + fun screenEffectsProfileId(mode: String, gameId: String?, program: String?): String? { + if (mode == SessionService.MODE_DESKTOP) return "desktop" + val id = gameId?.trim()?.takeIf { it.isNotEmpty() } + if (id != null) return "game:$id" + return if (mode == SessionService.MODE_RUN) { + program?.trim()?.takeIf { it.isNotEmpty() }?.let { "program:$it" } + } else null + } + + fun activeScreenEffectsProfileId(context: Context): String? = + prefs(context).getString(SCREEN_EFFECTS_ACTIVE_PROFILE_KEY, null)?.takeIf { it.isNotBlank() } + + fun setActiveScreenEffectsProfile(context: Context, profileId: String?) { + prefs(context).edit().putString(SCREEN_EFFECTS_ACTIVE_PROFILE_KEY, profileId.orEmpty()).apply() + } + fun screenEffects(context: Context): ScreenEffects { val text = prefs(context).getString("screenEffects", null) ?: return ScreenEffects.OFF return runCatching { ScreenEffects.decode(JSONObject(text)) }.getOrDefault(ScreenEffects.OFF) } + fun screenEffects(context: Context, profileId: String?): ScreenEffects { + if (profileId.isNullOrBlank()) return screenEffects(context) + val storedProfiles = prefs(context).getString(SCREEN_EFFECTS_PROFILES_KEY, null) + val profile = storedProfiles?.let { raw -> + runCatching { JSONObject(raw).optJSONObject(profileId) }.getOrNull() + } + return profile?.let { + runCatching { ScreenEffects.decode(it) }.getOrDefault(ScreenEffects.OFF) + } ?: screenEffects(context) + } + fun setScreenEffects(context: Context, effects: ScreenEffects) { prefs(context).edit().putString("screenEffects", effects.encode().toString()).apply() } + fun setScreenEffects(context: Context, profileId: String?, effects: ScreenEffects) { + if (profileId.isNullOrBlank()) { + setScreenEffects(context, effects) + return + } + val sessionPrefs = prefs(context) + val profiles = runCatching { + JSONObject(sessionPrefs.getString(SCREEN_EFFECTS_PROFILES_KEY, null) ?: "{}") + }.getOrDefault(JSONObject()) + val encoded = effects.encode() + profiles.optJSONObject(profileId)?.let { savedProfile -> + if (savedProfile.has(SCREEN_EFFECTS_PROFILE_UPSCALER_KEY)) { + encoded.put( + SCREEN_EFFECTS_PROFILE_UPSCALER_KEY, + savedProfile.optInt(SCREEN_EFFECTS_PROFILE_UPSCALER_KEY), + ) + } + } + profiles.put(profileId, encoded) + sessionPrefs.edit().putString(SCREEN_EFFECTS_PROFILES_KEY, profiles.toString()).apply() + } + + fun hasScreenEffectsUpscalerOverride(context: Context, profileId: String?): Boolean { + if (profileId.isNullOrBlank()) return false + return runCatching { + val profiles = JSONObject(prefs(context).getString(SCREEN_EFFECTS_PROFILES_KEY, null) ?: "{}") + profiles.optJSONObject(profileId)?.has(SCREEN_EFFECTS_PROFILE_UPSCALER_KEY) == true + }.getOrDefault(false) + } + + fun screenEffectsUpscaler(context: Context, profileId: String?): Int { + if (profileId.isNullOrBlank()) return upscaler(context) + val stored = runCatching { + val profiles = JSONObject(prefs(context).getString(SCREEN_EFFECTS_PROFILES_KEY, null) ?: "{}") + val profile = profiles.optJSONObject(profileId) + if (profile?.has(SCREEN_EFFECTS_PROFILE_UPSCALER_KEY) == true) { + profile.optInt(SCREEN_EFFECTS_PROFILE_UPSCALER_KEY, -1) + } else -1 + }.getOrDefault(-1) + return if (stored >= 0) canonicalUpscaler(stored) else upscaler(context) + } + + fun setScreenEffectsUpscaler(context: Context, profileId: String?, mode: Int) { + if (profileId.isNullOrBlank()) { + setUpscaler(context, mode) + return + } + val sessionPrefs = prefs(context) + val profiles = runCatching { + JSONObject(sessionPrefs.getString(SCREEN_EFFECTS_PROFILES_KEY, null) ?: "{}") + }.getOrDefault(JSONObject()) + val profile = profiles.optJSONObject(profileId) + ?: screenEffects(context, profileId).encode() + profile.put(SCREEN_EFFECTS_PROFILE_UPSCALER_KEY, canonicalUpscaler(mode)) + profiles.put(profileId, profile) + sessionPrefs.edit().putString(SCREEN_EFFECTS_PROFILES_KEY, profiles.toString()).apply() + } + + fun screenEffectsProfileIds(context: Context): Set { + val profiles = runCatching { + JSONObject(prefs(context).getString(SCREEN_EFFECTS_PROFILES_KEY, null) ?: "{}") + }.getOrElse { JSONObject() } + return buildSet { + val keys = profiles.keys() + while (keys.hasNext()) add(keys.next()) + } + } + + fun hasScreenEffectsOverride(context: Context, profileId: String?): Boolean { + if (profileId.isNullOrBlank()) return prefs(context).contains("screenEffects") + return profileId in screenEffectsProfileIds(context) + } + + fun resetScreenEffectsProfile(context: Context, profileId: String?) { + setScreenEffects(context, profileId, ScreenEffects.OFF) + } + + fun deleteScreenEffectsProfile(context: Context, profileId: String?) { + if (profileId.isNullOrBlank()) return + val sessionPrefs = prefs(context) + val profiles = runCatching { + JSONObject(sessionPrefs.getString(SCREEN_EFFECTS_PROFILES_KEY, null) ?: "{}") + }.getOrElse { JSONObject() } + if (!profiles.has(profileId)) return + profiles.remove(profileId) + sessionPrefs.edit().apply { + if (profiles.length() == 0) remove(SCREEN_EFFECTS_PROFILES_KEY) + else putString(SCREEN_EFFECTS_PROFILES_KEY, profiles.toString()) + }.apply() + } + const val CARDBOARD_KEY = "cardboard" fun cardboard(context: Context): Cardboard { diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt index d45bc531a6..b476c17ff1 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -114,7 +114,10 @@ class SessionService : Service() { private var freezePending = false private var freezeCancelled = false private var pendingSteamGameId: String? = null + private var pendingSteamPreviousGameId: String? = null + private var pendingSteamPreviousGamePending = false private var pendingSteamGameGeneration = -1 + private var pendingSteamGameExitWatchToken = -1 @Volatile private var gameExitWatchToken = 0 private val flushSteamGame = object : Runnable { override fun run() = flushQueuedSteamGame() @@ -390,9 +393,28 @@ class SessionService : Service() { pipTask = false SessionState.program = intent?.getStringExtra(EXTRA_PROGRAM) SessionState.programArgs = intent?.getStringArrayExtra(EXTRA_PROGRAM_ARGS)?.toList().orEmpty() - SessionState.gameId = intent?.getStringExtra(EXTRA_GAME_ID) SessionState.steamUi = intent?.getStringExtra(EXTRA_STEAM_UI) SessionState.steamUrl = intent?.getStringExtra(EXTRA_STEAM_URL) + val steamUrlGameId = SessionState.steamUrl + ?.let { url -> + when { + url.startsWith(GAME_URL_PREFIX) -> + url.removePrefix(GAME_URL_PREFIX) + url.startsWith("steam://run/") -> + url.removePrefix("steam://run/") + else -> null + } + } + ?.takeIf(GameLaunchLink::validId) + val resolvedGameId = intent?.getStringExtra(EXTRA_GAME_ID) + ?.trim() + ?.takeIf(GameLaunchLink::validId) + ?: steamUrlGameId + SessionState.gameId = resolvedGameId + SessionPrefs.setActiveScreenEffectsProfile( + this, + SessionPrefs.screenEffectsProfileId(SessionState.mode, resolvedGameId, SessionState.program), + ) com.droiddeck.launcher.stores.battlenet.BattleNetClient.clearRequests(LinuxRuntime.sessionRoot(this)) val gen = synchronized(stopLock) { SessionState.steamClientArch = null @@ -413,8 +435,9 @@ class SessionService : Service() { if (SessionPrefs.clearCachedApps(this)) clearCachedApps() cancelQueuedSteamGame(clearMailbox = false) clearSteamGameMailbox() - if (SessionState.mode == MODE_STEAM) SessionState.steamUrl - ?.takeIf { it.startsWith(GAME_URL_PREFIX) }?.let { watchGameExit(it.removePrefix(GAME_URL_PREFIX), gen) } + if (SessionState.mode == MODE_STEAM) { + resolvedGameId?.let { watchGameExit(it, gen, ++gameExitWatchToken) } + } acquireLocks() Thread({ OrphanReaper.reap("session starting") @@ -893,7 +916,7 @@ class SessionService : Service() { if (EnhancedDiagnostics.isActive(this, sessionDir)) SessionEvents.record("diagnostics.enhanced", mapOf("schema" to 1)) DeviceReport.write(this, File(sessionDir, "device.txt"), SessionState.mode) NetworkReport.write(this, File(sessionDir, "network.txt")) - SessionLogCapture.start(File(sessionDir, "app.log")) + SessionLogCapture.start(File(sessionDir, "app.log"), SessionPaths.startedAt(sessionDir)) MemoryLog.start() return sessionDir } @@ -1014,13 +1037,13 @@ class SessionService : Service() { guest.add("BL_ZRAM=1") if (steamHere) SessionPrefs.ramCapMb(this).takeIf { it > 0 }?.let { guest.add("BL_RAM_CAP_MB=$it") } if (!SessionPrefs.zramClient(this)) guest.add("BL_ZRAM_CLIENT=0") + if (!SessionPrefs.zramIdle(this)) guest.add("BL_ZRAM_IDLE=0") } SessionPrefs.vramCapMb(this).takeIf { it > 0 }?.let { guest.add("BL_VRAM_MB=$it") } guest.add("AUDIO_DIRECT_DECAY=0") val extra = extraEnv() + agentEnvironment - mapOf("TU_DEBUG" to (tuOverride ?: if (tuDriver) "sysmem" else ""), "MESA_NO_ERROR" to "").forEach { (name, game) -> - if (extra.none { it.startsWith("$name=") }) guest.add("$GAME_PREFIX$name=$game") - } + guest.addAll(TurnipEnvironment.gameEnvironment(tuOverride, tuDriver, SessionPrefs.tuSysmem(this), extra)) + if (extra.none { it.startsWith("MESA_NO_ERROR=") }) guest.add("${GAME_PREFIX}MESA_NO_ERROR=") extra.forEach { guest.add(it) } com.droiddeck.launcher.gpu.TpUbwcHint.forThisDevice(this)?.let { guest.add("${com.droiddeck.launcher.gpu.TpUbwcHint.ENV}=$it") } val clientPinned = steamHere && SessionPrefs.clientCpusOverride(this) @@ -1521,7 +1544,19 @@ class SessionService : Service() { return } val accepted = gameId!! - if (pendingSteamGameId != null) Log.i(TAG, "replacing a queued game launch with $accepted") + if (!pendingSteamPreviousGamePending) { + pendingSteamPreviousGameId = SessionState.gameId + pendingSteamPreviousGamePending = true + } + if (pendingSteamGameId != null) { + Log.i(TAG, "replacing queued game ${pendingSteamGameId} with $accepted") + } + pendingSteamGameExitWatchToken = ++gameExitWatchToken + SessionState.gameId = accepted + val effectsProfileId = SessionPrefs.screenEffectsProfileId(MODE_STEAM, accepted, null) + SessionPrefs.setActiveScreenEffectsProfile(this, effectsProfileId) + SessionPrefs.screenEffects(this, effectsProfileId) + .push(SessionPrefs.screenEffectsUpscaler(this, effectsProfileId)) pendingSteamGameId = accepted pendingSteamGameGeneration = sessionGen if (SessionState.suspended) resumeSession() @@ -1532,9 +1567,29 @@ class SessionService : Service() { private fun flushQueuedSteamGame() { val gameId = pendingSteamGameId ?: return val gen = pendingSteamGameGeneration + val exitWatchToken = pendingSteamGameExitWatchToken + if (exitWatchToken != gameExitWatchToken) return if (gen != sessionGen || !SessionState.running || SessionState.stopRequested || - SessionState.mode != MODE_STEAM || !GameLaunchLink.validId(gameId)) { + SessionState.mode != MODE_STEAM || SessionState.gameId != gameId || + !GameLaunchLink.validId(gameId)) { + val previousGameId = pendingSteamPreviousGameId + val queuedProfileId = SessionPrefs.screenEffectsProfileId(MODE_STEAM, gameId, null) + val canRestore = gen == sessionGen && + SessionState.running && !SessionState.stopRequested && + SessionState.mode == MODE_STEAM && + SessionState.gameId == gameId && + SessionPrefs.activeScreenEffectsProfileId(this) == queuedProfileId + cancelQueuedSteamGame() + + if (canRestore) { + SessionState.gameId = previousGameId + val previousProfileId = + SessionPrefs.screenEffectsProfileId(MODE_STEAM, previousGameId, null) + SessionPrefs.setActiveScreenEffectsProfile(this, previousProfileId) + SessionPrefs.screenEffects(this, previousProfileId) + .push(SessionPrefs.screenEffectsUpscaler(this, previousProfileId)) + } return } if (SessionState.suspended) { @@ -1561,33 +1616,95 @@ class SessionService : Service() { } pendingSteamGameId = null pendingSteamGameGeneration = -1 + pendingSteamGameExitWatchToken = -1 SessionEvents.record("steam.game_launch_requested", mapOf("gameId" to gameId, "generation" to gen)) - watchGameExit(gameId, gen) + watchGameExit(gameId, gen, exitWatchToken, pendingSteamPreviousGameId) Log.i(TAG, "queued Steam game $gameId for the running client") } - private fun watchGameExit(gameId: String, gen: Int) { - if (!SessionPrefs.returnAfterGame(this)) return - val token = ++gameExitWatchToken + private fun watchGameExit( + gameId: String, + gen: Int, + token: Int, + previousGameId: String? = null + ) { Thread({ - val startBy = android.os.SystemClock.elapsedRealtime() + GAME_START_TIMEOUT_MS + var startupRemaining = GAME_START_TIMEOUT_MS + var lastStartupCheck = android.os.SystemClock.elapsedRealtime() + var startupWasSuspended = false var seen = false var goneSince = 0L while (token == gameExitWatchToken && gen == sessionGen && SessionState.running && !SessionState.stopRequested) { val now = android.os.SystemClock.elapsedRealtime() - if (steamGameRunning()) { - if (!seen) Log.i(TAG, "game $gameId started; returning to the launcher when it closes") + val startupSuspended = SessionState.suspended || SessionState.suspending || SessionState.phase != SessionPhase.READY + if (!seen) { + if (startupSuspended) { + startupWasSuspended = true + lastStartupCheck = now + } else if (startupWasSuspended) { + startupWasSuspended = false + lastStartupCheck = now + } else { + startupRemaining -= (now - lastStartupCheck).coerceAtLeast(0L) + lastStartupCheck = now + } + } + if (steamGameRunning(gameId)) { + if (!seen) { + Log.i(TAG, "game $gameId started; tracking its exit") + mainHandler.post { + if (token == gameExitWatchToken && gen == sessionGen && + pendingSteamPreviousGamePending && + pendingSteamPreviousGameId == previousGameId) { + pendingSteamPreviousGameId = null + pendingSteamPreviousGamePending = false + } + } + } seen = true goneSince = 0L } else if (!seen) { - if (now > startBy) { - Log.i(TAG, "game $gameId did not start; not watching for its exit") + if (!startupSuspended && startupRemaining <= 0L) { + mainHandler.post { + if (token != gameExitWatchToken || gen != sessionGen || + !SessionState.running || SessionState.stopRequested) { + return@post + } + + if (previousGameId != null && steamGameRunning(previousGameId)) { + Log.w(TAG, "game $gameId did not start; restoring previous game $previousGameId") + SessionState.gameId = previousGameId + val previousProfileId = + SessionPrefs.screenEffectsProfileId(MODE_STEAM, previousGameId, null) + val failedGameProfileId = + SessionPrefs.screenEffectsProfileId(MODE_STEAM, gameId, null) + if (SessionPrefs.activeScreenEffectsProfileId(this@SessionService) == failedGameProfileId) { + SessionPrefs.setActiveScreenEffectsProfile(this@SessionService, previousProfileId) + SessionPrefs.screenEffects(this@SessionService, previousProfileId) + .push(SessionPrefs.screenEffectsUpscaler(this@SessionService, previousProfileId)) + } + pendingSteamPreviousGameId = null + pendingSteamPreviousGamePending = false + watchGameExit(previousGameId, gen, token) + } else { + Log.i(TAG, "game $gameId did not start; clearing its screen effects profile") + pendingSteamPreviousGameId = null + pendingSteamPreviousGamePending = false + clearActiveScreenEffectsProfile(gameId, gen, token) + } + } return@Thread } } else if (goneSince == 0L) { goneSince = now } else if (now - goneSince >= GAME_EXIT_GRACE_MS) { - mainHandler.post { returnAfterGame(gameId, gen, token) } + mainHandler.post { + if (SessionPrefs.returnAfterGame(this@SessionService)) { + returnAfterGame(gameId, gen, token) + } else { + clearActiveScreenEffectsProfile(gameId, gen, token) + } + } return@Thread } try { Thread.sleep(GAME_EXIT_POLL_MS) } catch (e: InterruptedException) { return@Thread } @@ -1595,17 +1712,52 @@ class SessionService : Service() { }, "game-exit-watch").start() } - private fun returnAfterGame(gameId: String, gen: Int, token: Int) { - if (token != gameExitWatchToken || gen != sessionGen || !SessionState.running || - SessionState.stopRequested || SessionState.mode != MODE_STEAM || !SessionPrefs.returnAfterGame(this)) return - val written = runCatching { File(LinuxRuntime.sessionRoot(this), "steam-stop").writeText("") } - .onFailure { Log.w(TAG, "could not ask the client to exit after game $gameId", it) }.isSuccess - if (!written) return - SessionEvents.record("steam.return_after_game", mapOf("gameId" to gameId)) - Log.i(TAG, "game $gameId closed: asking the client to exit and returning to the launcher") + private fun clearActiveScreenEffectsProfile(gameId: String, gen: Int, token: Int) { + if (token != gameExitWatchToken || gen != sessionGen || !SessionState.running || SessionState.stopRequested) return + val gameProfileId = SessionPrefs.screenEffectsProfileId(MODE_STEAM, gameId, null) + if (SessionPrefs.activeScreenEffectsProfileId(this) != gameProfileId) return + SessionPrefs.setActiveScreenEffectsProfile(this, null) + SessionPrefs.screenEffects(this, null).push(SessionPrefs.screenEffectsUpscaler(this, null)) } - private fun steamGameRunning(): Boolean = SteamGameProcess.running() + private fun returnAfterGame(gameId: String, gen: Int, token: Int) { + mainHandler.postDelayed({ + if (token != gameExitWatchToken || gen != sessionGen || !SessionState.running || + SessionState.stopRequested || SessionState.mode != MODE_STEAM || + SessionState.gameId != gameId || pendingSteamGameId != null) { + return@postDelayed + } + + if (steamGameRunning(gameId)) { + Log.i(TAG, "game $gameId is running again; restarting its exit watcher") + watchGameExit(gameId, gen, token) + return@postDelayed + } + + if (SteamGameProcess.running()) { + Log.i(TAG, "another Steam game is still running after $gameId; checking again") + returnAfterGame(gameId, gen, token) + return@postDelayed + } + + clearActiveScreenEffectsProfile(gameId, gen, token) + + if (!SessionPrefs.returnAfterGame(this)) { + Log.i(TAG, "return after game disabled; keeping the Steam session open") + return@postDelayed + } + + val written = runCatching { File(LinuxRuntime.sessionRoot(this), "steam-stop").writeText("") } + .onFailure { Log.w(TAG, "could not ask the client to exit after game $gameId", it) }.isSuccess + if (!written) return@postDelayed + + SessionEvents.record("steam.return_after_game", mapOf("gameId" to gameId)) + Log.i(TAG, "game $gameId closed: asking the client to exit and returning to the launcher") + }, GAME_EXIT_CONFIRM_MS) + } + + private fun steamGameRunning(gameId: String): Boolean = + SteamGameProcess.running(gameId) private fun resumeSession(panelVisible: Boolean = true) { if (SessionState.suspended) SessionState.resumeRequested = true @@ -1625,7 +1777,11 @@ class SessionService : Service() { private fun cancelQueuedSteamGame(clearMailbox: Boolean = true) { mainHandler.removeCallbacks(flushSteamGame) pendingSteamGameId = null + pendingSteamPreviousGameId = null + pendingSteamPreviousGamePending = false pendingSteamGameGeneration = -1 + pendingSteamGameExitWatchToken = -1 + gameExitWatchToken++ if (clearMailbox) clearSteamGameMailbox() } @@ -2108,10 +2264,11 @@ class SessionService : Service() { syncWatcher = null val prootPid = sessionPid sessionPid = -1 + // The kept shell goes through the same teardown, which reads its descendants before signalling it. + val shell = SessionTerminal.detach(sessionGen)?.let { pid -> readStat(pid)?.second?.let { pid to it } } val auxiliary = synchronized(auxiliaryProcessesLock) { auxiliaryProcesses.toMap().also { auxiliaryProcesses.clear() } - } - SessionTerminal.clear(sessionGen) + } + listOfNotNull(shell) BottomDesktop.stop(this, stoppedGen) val controller = suspendController suspendController = null @@ -2448,6 +2605,7 @@ class SessionService : Service() { private const val GAME_URL_PREFIX = "steam://rungameid/" private const val GAME_START_TIMEOUT_MS = 20 * 60_000L private const val GAME_EXIT_GRACE_MS = 10_000L + private const val GAME_EXIT_CONFIRM_MS = 2_000L private const val GAME_EXIT_POLL_MS = 2_000L private const val NO_PAD_SWITCH = "Download/droiddeck-no-pad" private const val NO_UINPUT_SWITCH = "Download/droiddeck-no-uinput" diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionTerminal.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionTerminal.kt index c7ecba3bbf..a8dd31141b 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionTerminal.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionTerminal.kt @@ -14,6 +14,12 @@ object SessionTerminal { @Volatile private var launch: Launch? = null + private class Kept(val session: TerminalSession, val generation: Int) + + // The bottom screen's presentation is dismissed whenever another app covers that display + // (a browser opened for a sign-in), so its shell is kept for the next panel. + @Volatile private var kept: Kept? = null + fun prepare( command: List, hostEnvironment: Array, @@ -32,8 +38,41 @@ object SessionTerminal { ).also { it.mSessionName = "DroidDeck Linux shell" } } + fun reuse(client: TerminalSessionClient): TerminalSession? { + val current = kept ?: return null + if (current.generation != launch?.generation || !current.session.isRunning) { + kept = null + return null + } + current.session.updateTerminalSessionClient(client) + return current.session + } + + fun keep(session: TerminalSession) { + val generation = launch?.generation ?: return + kept = Kept(session, generation) + } + + fun release(session: TerminalSession?) { + if (session != null && kept?.session === session) kept = null + } + fun clear(generation: Int? = null) { val current = launch ?: return - if (generation == null || current.generation == generation) launch = null + if (generation == null || current.generation == generation) { + launch = null + kept?.session?.takeIf { it.pid > 0 }?.finishIfRunning() + kept = null + } + } + + /** Ends this generation's terminal without killing its shell, and returns the shell's pid if it still runs. */ + fun detach(generation: Int): Int? { + val current = launch ?: return null + if (current.generation != generation) return null + launch = null + val pid = kept?.session?.takeIf { it.isRunning && it.pid > 0 }?.pid + kept = null + return pid } } diff --git a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt index 17696c44a3..9a12c0159b 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt @@ -16,11 +16,11 @@ object SettingsReset { "dualScreenMode", "dualScreenSessionMode", "dualScreenLauncher", "dualScreenSessionControls", "androidTextFieldKeyboard", "gameStoresEnabled", "soundtracksEnabled", "soundtracksIngame", "gameStoresSpeedTier", "gameStoresParallel", "storesOpenTab", "storesShowMature", "storesInstallLanguage", - "hud", "hudDeck", "hudFps", "hudBattery", "hudGraph", "hudColor", "hudOpacity", "__KEEP_droidDeckHud__", "__KEEP_droidDeckHudPos__", "backHold", "backActionsInverted", "backDoubleTapMs", "touch", "osc", "shape", "steamController", + "hud", "hudDeck", "hudFps", "hudBattery", "hudGraph", "hudColor", "hudOpacity", "__KEEP_droidDeckHud__", "__KEEP_droidDeckHudPos__", "backHold", "backActionsInverted", "backDoubleTapMs", "touch", "pen", "penButton", "osc", "shape", "steamController", "gamepadLeft", "gamepadRight", "pipAutoEnter", "unfoldedControls", "unfoldedControlsWithController", "stretch16x9", "picturePosition", "railLabels", "agentTab", "navTabOrder", "navTabShelved", "navTabHidden", "pcKeyboardSize", "pcKeyboardOpacity", "pcKeyboardHiddenKeys", "gpuDriverMode", "androidDriver", "linuxDriver", "linuxDriver.steam", "linuxDriver.desktop", - "tuSysmem", "glThread", "noGlError", "zinkLazy", "mangoapp", "gpuClockPin", "gamescopeRealtime", "paceCores", "ramCapMb", "vramCapMb", "zramClient", + "tuSysmem", "glThread", "noGlError", "zinkLazy", "mangoapp", "gpuClockPin", "gamescopeRealtime", "paceCores", "ramCapMb", "vramCapMb", "zramClient", "zramIdle", "directAudio", "mic", "wifiDiscovery", "clientCpusOverride", "clientCpus", "gameCpus", "noXalia", "fastSync", "fsyncFirst", "syncFallback", "prootNoSeccomp", "prootFastPath", "nativeUserland", "cursorComposite", "guestHostname", "fexPreset", "forceSsbs", "logs", "gameDebugLogsEnabled", "enhancedDiagnosticsNext", "storageDiagnostics", "buildWatermark", diff --git a/app/src/main/java/com/droiddeck/launcher/session/SteamGameProcess.kt b/app/src/main/java/com/droiddeck/launcher/session/SteamGameProcess.kt index 891fb57ca8..13a88ee493 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SteamGameProcess.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SteamGameProcess.kt @@ -5,14 +5,59 @@ import java.io.File object SteamGameProcess { fun matches(cmdline: ByteArray): Boolean { val args = String(cmdline).split('\u0000') - for (i in args.indices) { - if (args[i] == "waitforexitandrun") return true - if (args[i] == "SteamLaunch" && args.getOrNull(i + 1)?.startsWith("AppId=") == true) return true + return args.indices.any { i -> + args[i] == "waitforexitandrun" || + (args[i] == "SteamLaunch" && + args.getOrNull(i + 1)?.startsWith("AppId=") == true) } + } + + fun running(): Boolean = + File("/proc").listFiles()?.any { p -> + p.name.all(Char::isDigit) && + runCatching { File(p, "cmdline").readBytes() } + .getOrNull()?.let(::matches) == true + } == true + private fun steamAppIdForGameId(gameId: String): String? { + if (gameId.isEmpty() || !gameId.all(Char::isDigit)) return null + + val numericId = gameId.toULongOrNull() ?: return null + val appId = if (numericId > UInt.MAX_VALUE.toULong()) { + numericId shr 32 + } else { + numericId + } + + return appId.takeIf { it != 0uL }?.toString() + } + + fun matches(cmdline: ByteArray, gameId: String): Boolean { + val expectedAppId = steamAppIdForGameId(gameId) ?: return false + val args = String(cmdline).split('\u0000') + + for (i in args.indices) { + if (args[i] == "SteamLaunch") { + val appId = args.getOrNull(i + 1) + ?.takeIf { it.startsWith("AppId=") } + ?.removePrefix("AppId=") + + if (appId == expectedAppId) return true + } + + if (args[i] == "-applaunch" && + args.getOrNull(i + 1) == expectedAppId + ) { + return true + } + } + return false } - fun running(proc: File = File("/proc")): Boolean = proc.listFiles()?.any { p -> - p.name.all(Char::isDigit) && runCatching { File(p, "cmdline").readBytes() }.getOrNull()?.let(::matches) == true - } == true + fun running(gameId: String, proc: File = File("/proc")): Boolean = + proc.listFiles()?.any { p -> + p.name.all(Char::isDigit) && + runCatching { File(p, "cmdline").readBytes() } + .getOrNull()?.let { matches(it, gameId) } == true + } == true } diff --git a/app/src/main/java/com/droiddeck/launcher/session/TurnipEnvironment.kt b/app/src/main/java/com/droiddeck/launcher/session/TurnipEnvironment.kt new file mode 100644 index 0000000000..7fc460b3f6 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/session/TurnipEnvironment.kt @@ -0,0 +1,16 @@ +package com.droiddeck.launcher.session + +internal object TurnipEnvironment { + const val GAME_TU_DEBUG = "DROIDDECK_GAME_TU_DEBUG" + + fun gameEnvironment( + tuOverride: String?, + tuDriver: Boolean, + tuSysmem: Boolean, + extra: List, + ): List = if (extra.none { it.startsWith("TU_DEBUG=") }) { + listOf("$GAME_TU_DEBUG=${tuOverride ?: if (tuDriver || tuSysmem) "sysmem" else ""}") + } else { + emptyList() + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/stores/CloudSaves.kt b/app/src/main/java/com/droiddeck/launcher/stores/CloudSaves.kt index 106719d559..45b1be5429 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/CloudSaves.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/CloudSaves.kt @@ -25,9 +25,11 @@ object CloudSaves { private const val PARALLEL = 6 private const val CLOUD_LAYOUT = 2 - class Result(val result: String, val files: Int, val bytes: Long, val reason: String, val conflicts: Int = 0) { + class Result(val result: String, val files: Int, val bytes: Long, val reason: String, val conflicts: Int = 0, val detail: String = "") { val ok: Boolean get() = result != "failed" - val line: String get() = "result=$result files=$files bytes=$bytes reason=$reason" + if (conflicts > 0) " conflicts=$conflicts" else "" + val line: String get() = "result=$result files=$files bytes=$bytes reason=$reason" + + (if (conflicts > 0) " conflicts=$conflicts" else "") + + if (detail.isNotEmpty()) " detail=\"$detail\"" else "" } class Status(val supported: Boolean, val folder: File?, val lastSync: Long, val reason: String, val conflicts: List = emptyList()) @@ -126,7 +128,7 @@ object CloudSaves { ) if (picked == null) GogConfig("", "") else GogConfig(picked.name, picked.template) } catch (e: Exception) { - Log.w(TAG, "gog remote-config: ${e.javaClass.simpleName}") + Log.w(TAG, "gog remote-config: ${cloudFailureDetail(e)}") null } } @@ -166,7 +168,7 @@ object CloudSaves { val galaxy = GogAuth.validToken(context) val clientId = gogClientId(context, id, folder) if (userId.isEmpty() || galaxy == null || clientId == null) null - else GogCloud(userId, clientId, gogScopedToken(context, id, clientId) ?: galaxy, gogLocationName(context, id, folder)) + else GogCloud(userId, clientId, gogScopedToken(context, id, clientId) ?: galaxy, gogLocationName(context, id, folder), tempDir = context.cacheDir) } Store.EPIC -> { val token = EpicCredentialStore.getValidAccessToken(context) @@ -312,7 +314,7 @@ object CloudSaves { rememberNoCloud(prefs(context, store), id) Result("skipped", 0, 0, "no-cloud-saves") } catch (e: Exception) { - Result("failed", 0, 0, e.javaClass.simpleName) + Result("failed", 0, 0, e.javaClass.simpleName, detail = cloudFailureDetail(e)) } return done(store, id, way, result) } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/CloudTransport.kt b/app/src/main/java/com/droiddeck/launcher/stores/CloudTransport.kt index ecf318068e..2971bb61ca 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/CloudTransport.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/CloudTransport.kt @@ -59,6 +59,69 @@ private fun httpDate(s: String?): Long = try { SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US).apply { timeZone = TimeZone.getTimeZone("GMT") }.parse(s!!.trim())?.time ?: -1L } catch (e: Exception) { -1L } +private val SECRET_PARAM = Regex("(?i)(token|secret|code|password|authorization)([\"']?\\s*[:=]\\s*[\"']?)[^\\s&\"',;}]+") +private val BEARER = Regex("(?i)bearer\\s+\\S+") +private val URL_TEXT = Regex("(?i)https?://(?:[^/\\s?#@]*@)?([^/\\s?#@]+)[^\\s]*") +private val LONG_TOKEN = Regex("[A-Za-z0-9._~+/=-]{32,}") +private val SPACES = Regex("\\s+") +private const val DETAIL_MAX = 400 + +internal fun scrubCloudText(text: String, longTokens: Boolean = true): String = text + .replace(BEARER, "Bearer ") + .replace(URL_TEXT) { it.groupValues[1] } + .replace(SECRET_PARAM) { it.groupValues[1] + it.groupValues[2] + "" } + .let { if (longTokens) it.replace(LONG_TOKEN, "") else it } + .replace(SPACES, " ") + .trim() + +internal fun cloudFailureDetail(e: Throwable): String { + val parts = ArrayList() + var t: Throwable? = e + while (t != null && parts.size < 3) { + val message = t.message?.let { scrubCloudText(it, longTokens = false) }.orEmpty() + parts += if (message.isEmpty()) t.javaClass.simpleName else "${t.javaClass.simpleName}: $message" + t = t.cause?.takeIf { it !== t } + } + return parts.joinToString(" <- ").take(DETAIL_MAX) +} + +private const val SNIPPET_READ_MAX = 4096 +private const val SNIPPET_MAX = 120 + +private data class CloudErrorPrefix(val text: String, val truncated: Boolean) { + fun snippet(): String { + val safe = if (truncated) text.substring(0, text.indexOfLast { it.isWhitespace() }.coerceAtLeast(0)) else text + return scrubCloudText(safe).take(SNIPPET_MAX) + } +} + +private fun cloudErrorPrefix(input: InputStream?): CloudErrorPrefix { + if (input == null) return CloudErrorPrefix("", false) + return input.use { stream -> + val buffer = ByteArray(SNIPPET_READ_MAX + 1) + var read = 0 + while (read < buffer.size) { + val n = stream.read(buffer, read, buffer.size - read) + if (n < 0) break + read += n + } + CloudErrorPrefix(buffer.decodeToString(0, minOf(read, SNIPPET_READ_MAX)), read > SNIPPET_READ_MAX) + } +} + +internal fun cloudErrorSnippet(input: InputStream?): String = + cloudErrorPrefix(input).snippet() + +private fun HttpURLConnection.errorSnippet(): String = + runCatching { cloudErrorSnippet(errorStream) }.getOrDefault("") + +private fun httpFailure(step: String, name: String?, code: Int, error: String): java.io.IOException = + java.io.IOException(buildString { + append("GOG cloud ").append(step).append(" HTTP ").append(code) + if (name != null) append(" file=").append(name) + if (error.isNotEmpty()) append(" body=").append(error) + }) + internal fun isGzip(data: ByteArray) = data.size >= 10 && data[0] == 0x1f.toByte() && data[1] == 0x8b.toByte() && data[2] == 0x08.toByte() @@ -183,6 +246,8 @@ private fun gzipFile(src: File, dst: File): GzipFile { } } +internal const val GOG_CLOUD_UA = "GOGGalaxyCommunicationService/2.0.13.27 (Windows_32bit) dont_sync_marker/true installation_source/gog" + /** GOG Galaxy parses `X-Object-Meta-LocalLastModified`; objects without it fail as "invalid data". */ private val GOG_STAMP = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssxxx", Locale.US) @@ -195,9 +260,10 @@ class GogCloud( private val token: String, private val location: String? = null, baseUrl: String? = null, + private val tempDir: File? = null, ) : CloudTransport { private val base = baseUrl ?: "https://cloudstorage.gog.com/v1/$userId/$clientId" - private val ua = "GOG Galaxy" + private val ua = GOG_CLOUD_UA private var prefix: String? = location?.let { "$it/" } private fun key(name: String) = URLEncoder.encode(name, "UTF-8").replace("+", "%20") @@ -209,10 +275,10 @@ class GogCloud( val code = c.responseCode if (code == 404) { c.disconnect(); return emptyList() } if (code !in 200..299) { - val err = runCatching { c.errorStream?.readBytes()?.decodeToString().orEmpty() }.getOrDefault("") + val err = runCatching { cloudErrorPrefix(c.errorStream) }.getOrDefault(CloudErrorPrefix("", false)) c.disconnect() - if ("not_enabled_for_client" in err || "disabled" in err) throw NoCloudSaves() - throw java.io.IOException("GOG cloud list HTTP $code") + if ("not_enabled_for_client" in err.text || "disabled" in err.text) throw NoCloudSaves() + throw httpFailure("list", null, code, err.snippet()) } val text = c.body().decodeToString().trim() c.disconnect() @@ -255,12 +321,20 @@ class GogCloud( override fun get(file: CloudFile): Pair { val c = open("$base/${cloudKey(file.name)}", "GET", token, ua) c.setRequestProperty("Accept-Encoding", "identity") - if (c.responseCode !in 200..299) { val code = c.responseCode; c.disconnect(); throw java.io.IOException("GOG cloud get HTTP $code") } + if (c.responseCode !in 200..299) { + val code = c.responseCode + val err = c.errorSnippet() + c.disconnect() + throw httpFailure("get", file.name, code, err) + } val modified = httpDate(c.getHeaderField("Last-Modified")) val encoding = c.getHeaderField("Content-Encoding") - val data = c.body() - c.disconnect() - return gogDecodeCloudBody(data, encoding) to modified + val data = try { c.body() } finally { c.disconnect() } + return try { + gogDecodeCloudBody(data, encoding) to modified + } catch (e: java.io.IOException) { + throw java.io.IOException("GOG cloud get file=${file.name} bytes=${data.size} encoding=$encoding", e) + } } override fun put(files: Map, modifiedMs: Map): Map = files.mapValues { (name, data) -> @@ -269,7 +343,11 @@ class GogCloud( } override fun putFiles(files: Map, modifiedMs: Map): Map = files.mapValues { (name, file) -> - val compressed = File.createTempFile("gog-cloud-", ".gz") + val compressed = try { + File.createTempFile("gog-cloud-", ".gz", tempDir?.apply { mkdirs() }) + } catch (e: java.io.IOException) { + throw java.io.IOException("GOG cloud put file=$name temp file", e) + } try { val gz = gzipFile(file, compressed) val modified = putBody(name, compressed.inputStream(), gz.length, gz.etag, modifiedMs[name] ?: file.lastModified()) @@ -287,10 +365,16 @@ class GogCloud( c.setRequestProperty("Content-Encoding", "gzip") c.setRequestProperty("Etag", etag) c.setRequestProperty("X-Object-Meta-LocalLastModified", gogStamp(modified)) + c.setRequestProperty("X-Object-Meta-User-Agent", ua) c.setFixedLengthStreamingMode(length) - c.outputStream.use { out -> source.use { it.copyTo(out, 64 * 1024) } } + try { + c.outputStream.use { out -> source.use { it.copyTo(out, 64 * 1024) } } + } catch (e: java.io.IOException) { + val code = runCatching { c.responseCode }.getOrNull() + throw java.io.IOException("GOG cloud put file=$name bytes=$length" + (code?.let { " HTTP $it" } ?: ""), e) + } val code = c.responseCode - if (code !in 200..299) throw java.io.IOException("GOG cloud put HTTP $code") + if (code !in 200..299) throw httpFailure("put", name, code, c.errorSnippet()) return CloudFile(name, -1L).also { details(it) }.modifiedMs } finally { c.disconnect() diff --git a/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicBackend.kt b/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicBackend.kt index 394164c4c3..fb9c5c8ab4 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicBackend.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicBackend.kt @@ -84,6 +84,11 @@ object EpicBackend : StoreBackend, EpicLaunchSupport { Store.EPIC, item.id, item.title, cover = item.imageUrl, bytesTotal = item.sizeBytes, location = StoreInstallRoot.labelFor(app, folder), ) + val launcher = item.extra["thirdPartyManagedApp"].orEmpty() + if (launcher.isNotBlank()) { + DownloadQueue.recordFailed(app, entry, app.getString(R.string.epic_third_party_managed, launcher)) + return + } DownloadQueue.enqueue(app, entry) { EpicInstaller(app, item, folder) } } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicLibrary.kt b/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicLibrary.kt index 32a485bfba..f9ae36b192 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicLibrary.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicLibrary.kt @@ -26,6 +26,7 @@ data class EpicGame( val publisher: String = "", val isDlc: Boolean = false, val artLogo: String = "", + val thirdPartyManagedApp: String = "", ) object EpicLibrary { @@ -52,7 +53,10 @@ object EpicLibrary { .put("developer", g.developer).put("description", g.description).put("version", g.version) .put("installSize", g.installSize).put("canRunOffline", g.canRunOffline) .put("releaseDate", g.releaseDate).put("publisher", g.publisher) - .apply { if (g.artLogo.isNotEmpty()) put("artLogo", g.artLogo) }, + .apply { + if (g.artLogo.isNotEmpty()) put("artLogo", g.artLogo) + if (g.thirdPartyManagedApp.isNotEmpty()) put("thirdPartyManagedApp", g.thirdPartyManagedApp) + }, ) }.toString() @@ -76,6 +80,7 @@ object EpicLibrary { releaseDate = o.optString("releaseDate", ""), publisher = o.optString("publisher", ""), artLogo = o.optString("artLogo", ""), + thirdPartyManagedApp = o.optString("thirdPartyManagedApp", ""), ) } return tidy(games) @@ -108,7 +113,12 @@ object EpicLibrary { owned = true, sizeBytes = prefs.getLong("size_${game.appName}", 0L).takeIf { it > 0 } ?: game.installSize, storeUrl = "https://store.epicgames.com/en-US/browse?q=" + URLEncoder.encode(title, "UTF-8"), - extra = mapOf("namespace" to game.namespace, "catalogItemId" to game.catalogItemId, "version" to game.version), + extra = mapOf( + "namespace" to game.namespace, + "catalogItemId" to game.catalogItemId, + "version" to game.version, + "thirdPartyManagedApp" to game.thirdPartyManagedApp, + ), logoUrl = game.artLogo.ifEmpty { null }, ) } @@ -133,6 +143,7 @@ object EpicLibrary { publisher = pick("publisher", before?.publisher.orEmpty()), isDlc = d.optBoolean("dlc", false), artLogo = pick("logo", before?.artLogo.orEmpty()), + thirdPartyManagedApp = details?.optString("thirdPartyManagedApp", "") ?: before?.thirdPartyManagedApp.orEmpty(), ) } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/AgentPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/AgentPage.kt index 3bc13a5f20..30e7e9e01b 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/AgentPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/AgentPage.kt @@ -145,11 +145,30 @@ internal fun AgentPage( internal fun AgentPageWithControls( modifier: Modifier, inputModifier: Modifier = Modifier, visible: Boolean = true, startTyping: Boolean = true, showControlsWithoutKeyboard: Boolean, -) = AgentPageContent(modifier, inputModifier, visible, hidesPet = true) +) = AgentPageContent(modifier, inputModifier, visible, hidesPet = true, drawer = true) + +/** Whether the session drawer's chat keeps the model, usage and menu in the editor's row, giving the conversation that row's height. */ +internal object AgentDrawerLayout { + private const val KEY = "drawer_inline_controls" + var inline by mutableStateOf(true) + private set + private var loaded = false + + fun load(context: android.content.Context) { + if (loaded) return + loaded = true + inline = AgentHost.prefs(context).getBoolean(KEY, true) + } + + fun set(context: android.content.Context, on: Boolean) { + inline = on + AgentHost.prefs(context).edit().putBoolean(KEY, on).apply() + } +} @Composable private fun AgentPageContent( - modifier: Modifier, inputModifier: Modifier, visible: Boolean, hidesPet: Boolean, menuSlot: AgentMenuSlot? = null, + modifier: Modifier, inputModifier: Modifier, visible: Boolean, hidesPet: Boolean, menuSlot: AgentMenuSlot? = null, drawer: Boolean = false, ) { val context = LocalContext.current val view = LocalView.current @@ -164,6 +183,8 @@ private fun AgentPageContent( } } remember { AgentHost.refresh(context) } + remember { AgentDrawerLayout.load(context) } + val inline = drawer && AgentDrawerLayout.inline LaunchedEffect(AgentHost.unseen, visible) { if (visible) AgentHost.seen() } // A stopped activity keeps its composition; the page is only on screen while its host is started. val lifecycle = androidx.compose.ui.platform.LocalLifecycleOwner.current.lifecycle @@ -190,11 +211,15 @@ private fun AgentPageContent( val focusManager = LocalFocusManager.current val togglePanel: (AgentPanel) -> Unit = { panel = if (panel == it) AgentPanel.NONE else it } var menuOpen by rememberSaveable { mutableStateOf(false) } - val topBar: @Composable () -> Unit = { - AgentTopBar(panel, togglePanel, inputModifier) { - AgentMenu(menuOpen, { menuOpen = it }, onPanel = { panel = it }, onSetup = { setup = true }) - } + val menu: @Composable () -> Unit = { + AgentMenu(menuOpen, { menuOpen = it }, onPanel = { panel = it }, onSetup = { setup = true }) } + val topBar: @Composable () -> Unit = { AgentTopBar(panel, togglePanel, inputModifier, menu) } + val inlineControls: (@Composable () -> Unit)? = if (inline) ({ + ModelChip(panel, togglePanel, inputModifier, compact = true) + ContextRing("agent-usage", onClick = { togglePanel(AgentPanel.USAGE) }) + menu() + }) else null // A host with a title bar shows the top bar there. val inSlot = menuSlot != null && panel != AgentPanel.HISTORY && panel != AgentPanel.PROCESSES && panel != AgentPanel.TOOLS if (menuSlot != null) DisposableEffect(menuSlot, inSlot) { @@ -226,7 +251,7 @@ private fun AgentPageContent( AgentToolsPanel(Modifier.weight(1f)) } else -> { - if (menuSlot == null) Box(Modifier.padding(bottom = 6.dp)) { topBar() } + if (menuSlot == null && !inline) Box(Modifier.padding(bottom = 6.dp)) { topBar() } when (panel) { AgentPanel.MODEL -> Box(Modifier.padding(bottom = 8.dp)) { AgentModelPicker() } AgentPanel.USAGE -> Box(Modifier.padding(bottom = 8.dp)) { AgentUsage() } @@ -279,7 +304,7 @@ private fun AgentPageContent( } } androidx.compose.animation.AnimatedVisibility(!hidden, enter = expandVertically() + fadeIn(), exit = shrinkVertically() + fadeOut()) { - AgentComposer(composer, draft, visible, onPanel = { panel = it }, onSent = toLatest) + AgentComposer(composer, draft, visible, inlineControls, onPanel = { panel = it }, onSent = toLatest) } } } @@ -315,27 +340,34 @@ internal class AgentMenuSlot { /** The model and how full the context is, then the [menu]. */ @Composable private fun AgentTopBar(panel: AgentPanel, onPanel: (AgentPanel) -> Unit, firstControl: Modifier, menu: @Composable () -> Unit) { - val context = LocalContext.current - val pal = LocalPalette.current Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.weight(1f)) { - val model = AgentHost.models(context).firstOrNull { it.id == AgentHost.model }?.label ?: AgentHost.model ?: stringResource(R.string.agent_model_default) - Row( - verticalAlignment = Alignment.CenterVertically, - modifier = Modifier.weight(1f, fill = false).height(36.dp).clip(Shape12).then(firstControl).clickable { onPanel(AgentPanel.MODEL) } - .padding(horizontal = 8.dp).testTag("agent-model"), - ) { - val parts = listOfNotNull(AgentHost.harness.name, model, AgentHost.effort, stringResource(R.string.agent_plan_short).takeIf { AgentHost.plan && AgentHost.harness.plans }) - Text(parts.joinToString(" · "), fontSize = 13.sp, color = if (panel == AgentPanel.MODEL) pal.primary else pal.onSurfaceVariant, - maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f, fill = false)) - Icon(Icons.Outlined.ExpandMore, null, tint = pal.onSurfaceVariant, modifier = Modifier.size(16.dp)) - } + ModelChip(panel, onPanel, firstControl, Modifier.weight(1f, fill = false)) ContextRing("agent-usage", onClick = { onPanel(AgentPanel.USAGE) }) } menu() } } +/** The harness, model, effort and plan mode, opening the model picker; [compact] names only the model. */ +@Composable +private fun ModelChip(panel: AgentPanel, onPanel: (AgentPanel) -> Unit, firstControl: Modifier, modifier: Modifier = Modifier, compact: Boolean = false) { + val context = LocalContext.current + val pal = LocalPalette.current + val model = AgentHost.models(context).firstOrNull { it.id == AgentHost.model }?.label ?: AgentHost.model ?: stringResource(R.string.agent_model_default) + Row( + verticalAlignment = Alignment.CenterVertically, + modifier = modifier.then(if (compact) Modifier.widthIn(max = 120.dp) else Modifier).height(36.dp).clip(Shape12).then(firstControl) + .clickable { onPanel(AgentPanel.MODEL) }.padding(horizontal = 8.dp).testTag("agent-model"), + ) { + val parts = if (compact) listOf(model) + else listOfNotNull(AgentHost.harness.name, model, AgentHost.effort, stringResource(R.string.agent_plan_short).takeIf { AgentHost.plan && AgentHost.harness.plans }) + Text(parts.joinToString(" · "), fontSize = 13.sp, color = if (panel == AgentPanel.MODEL) pal.primary else pal.onSurfaceVariant, + maxLines = 1, overflow = TextOverflow.Ellipsis, modifier = Modifier.weight(1f, fill = false)) + Icon(Icons.Outlined.ExpandMore, null, tint = pal.onSurfaceVariant, modifier = Modifier.size(16.dp)) + } +} + /** History, processes, a new conversation, the pet and setup, folded behind one button. */ @Composable private fun AgentMenu(open: Boolean, onOpen: (Boolean) -> Unit, onPanel: (AgentPanel) -> Unit, onSetup: () -> Unit) { @@ -620,7 +652,10 @@ internal fun usagePercent(): Int? { internal fun liveUsed(limit: AgentHost.Limit) = if (limit.resetsAt > 0 && limit.resetsAt * 1000 < System.currentTimeMillis()) 0 else limit.usedPercent @Composable -private fun AgentComposer(composer: ComposerState, draftState: MutableState, visible: Boolean, onPanel: (AgentPanel) -> Unit, onSent: () -> Unit) { +private fun AgentComposer( + composer: ComposerState, draftState: MutableState, visible: Boolean, controls: (@Composable () -> Unit)?, + onPanel: (AgentPanel) -> Unit, onSent: () -> Unit, +) { val context = LocalContext.current var draft by draftState var labOpen by rememberSaveable { mutableStateOf(false) } @@ -650,13 +685,13 @@ private fun AgentComposer(composer: ComposerState, draftState: MutableState, visible: Boolean, send: () -> Unit) { +private fun AgentEditor(composer: ComposerState, draftState: MutableState, visible: Boolean, controls: (@Composable () -> Unit)?, send: () -> Unit) { val context = LocalContext.current val colors = MaterialTheme.colorScheme val pal = LocalPalette.current @@ -717,6 +752,7 @@ private fun AgentEditor(composer: ComposerState, draftState: MutableState Unit = {}) { } } } + Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth().padding(horizontal = 2.dp)) { + Column(Modifier.weight(1f)) { + Text(stringResource(R.string.agent_drawer_inline), fontSize = 15.sp, fontWeight = FontWeight.SemiBold, color = colors.onBackground) + Text(stringResource(R.string.agent_drawer_inline_hint), fontSize = 12.5.sp, color = pal.onSurfaceVariant) + } + ToggleSwitch(AgentDrawerLayout.inline, label = stringResource(R.string.agent_drawer_inline), modifier = Modifier.testTag("setting-agent-drawer-inline")) { + AgentDrawerLayout.set(context, it) + } + } if (AgentSetup.ready || AgentSetup.completed(context)) PrimaryButton(stringResource(R.string.agent_setup_done), main = true, onClick = onDone) StorageCard() } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/AndroidAppsPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/AndroidAppsPage.kt index dce70549b2..4303dde0fe 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/AndroidAppsPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/AndroidAppsPage.kt @@ -341,7 +341,28 @@ internal fun AndroidAppsPage(s: FrontEndState, a: FrontEndActions, modifier: Mod openFolder = f.id } - Box(modifier) { + val ff = LocalFrontFocus.current + var holdFocus by remember { mutableStateOf(null) } + var pageFocused by remember { mutableStateOf(false) } + LaunchedEffect(holdFocus) { + val key = "tile:folder:${holdFocus ?: return@LaunchedEffect}" + // A folder closed from its name field: the platform field and the fading sheet both drop focus after the sheet asked for the tile, so keep asking until the sheet is gone. + val until = System.nanoTime() + 400_000_000L + while (System.nanoTime() < until) { + androidx.compose.runtime.withFrameNanos { } + if (ff != null && !(ff.last == key && pageFocused)) runCatching { ff.items[key]?.requestFocus() } + } + holdFocus = null + } + Box( + modifier.onFocusChanged { pageFocused = it.hasFocus } + // A fresh press means the user is moving on, so the hold must not pull focus back to the folder. + .onPreviewKeyEvent { event -> + val k = event.nativeKeyEvent + if (holdFocus != null && k.action == KeyEvent.ACTION_DOWN && k.repeatCount == 0) holdFocus = null + false + }, + ) { Column(Modifier.fillMaxSize().imePadding()) { Box(Modifier.fillMaxWidth().padding(start = padH, end = padH, top = if (narrow) 8.dp else 12.dp)) { ModeHeader( @@ -443,7 +464,7 @@ internal fun AndroidAppsPage(s: FrontEndState, a: FrontEndActions, modifier: Mod var last by remember { mutableStateOf(folder) } if (folder != null) last = folder last?.let { f -> - FolderSheet(f, f.apps.mapNotNull(member).filter { it.key !in hidden }.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.label }), renameOnOpen, onLaunch, newFolder, { iconFor = it }) { + FolderSheet(f, f.apps.mapNotNull(member).filter { it.key !in hidden }.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.label }), renameOnOpen, onLaunch, newFolder, { iconFor = it }, onHoldFocus = { holdFocus = f.id }) { openFolder = null renameOnOpen = false } @@ -813,7 +834,7 @@ private fun FolderTile(entry: AppEntry.Folder, first: Boolean, onOpen: () -> Uni private fun FolderSheet( folder: HomeFolders.Folder, apps: List, renameFirst: Boolean, onLaunch: (HomeApp.LaunchableApp) -> Unit, onNewFolder: (HomeApp.LaunchableApp) -> Unit, - onChangeIcon: (HomeApp.LaunchableApp) -> Unit, onClose: () -> Unit, + onChangeIcon: (HomeApp.LaunchableApp) -> Unit, onHoldFocus: () -> Unit, onClose: () -> Unit, ) { SwipeLock() val ctx = LocalContext.current @@ -831,20 +852,24 @@ private fun FolderSheet( val ff = LocalFrontFocus.current val grid = rememberLazyGridState() var closing by remember { mutableStateOf(false) } + var inside by remember { mutableStateOf(false) } LaunchedEffect(renaming, inputMode) { if (!renaming && !closing && inputMode == InputMode.Keyboard && apps.isNotEmpty()) { grid.scrollToItem(0) - repeat(2) { androidx.compose.runtime.withFrameNanos { } } - if (!closing) runCatching { firstApp.requestFocus() } + androidx.compose.runtime.withFrameNanos { } + // After touch, focus starts outside the page and the first request is turned to the page's own entry, behind the sheet. Ask until it is in here. + focusWithinFrames({ inside || closing }) { firstApp } } } val close = { + val wasRenaming = renaming closing = true if (renaming) commit() onClose() if (inputMode == InputMode.Keyboard && ff != null) { runCatching { ff.items.getValue("tile:folder:${folder.id}").requestFocus() } .onFailure { runCatching { ff.firstTile.requestFocus() } } + if (wasRenaming) onHoldFocus() } } BackHandler { close() } @@ -861,6 +886,7 @@ private fun FolderSheet( .glideBorder(false, Shape16, pal.signal, pal.signal.copy(alpha = 0.22f)) .pointerInput(Unit) { awaitEachGesture { awaitFirstDown(requireUnconsumed = false).consume() } } .controllerBack(close) + .onFocusChanged { inside = it.hasFocus } .focusProperties { exit = { dir -> if (dir == FocusDirection.Up || dir == FocusDirection.Down || dir == FocusDirection.Left || dir == FocusDirection.Right) FocusRequester.Cancel diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BottomDesktopPanel.kt b/app/src/main/java/com/droiddeck/launcher/ui/BottomDesktopPanel.kt index 88dd8c916e..a0033d81a7 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/BottomDesktopPanel.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/BottomDesktopPanel.kt @@ -28,6 +28,7 @@ import com.droiddeck.launcher.input.PointerGestures import com.droiddeck.launcher.input.TouchpadGestures import com.droiddeck.launcher.session.SessionPrefs import com.droiddeck.launcher.session.BottomDesktop +import com.droiddeck.launcher.wayland.WaylandCompositor @SuppressLint("ViewConstructor") class BottomDesktopPanel( @@ -289,10 +290,10 @@ class BottomDesktopPanel( override fun onButton(button: Int, pressed: Boolean, x: Float, y: Float) { movePointer(x, y) - BottomDesktop.sendScene(SCENE_BUTTON, button, if (pressed) 1 else 0) + BottomDesktop.sendScene(WaylandCompositor.SCENE_BUTTON, button, if (pressed) 1 else 0) } - override fun onWheel(steps: Int) = BottomDesktop.sendScene(SCENE_WHEEL, steps) + override fun onWheel(steps: Int) = BottomDesktop.sendScene(WaylandCompositor.SCENE_WHEEL, steps) override fun onScroll(dx: Float, dy: Float) { val (outW, outH) = BottomDesktop.outputSize @@ -303,18 +304,18 @@ class BottomDesktopPanel( if (h == 0 && v == 0) return scrollRestX -= h scrollRestY -= v - BottomDesktop.sendScene(SCENE_AXIS, v, h) + BottomDesktop.sendScene(WaylandCompositor.SCENE_AXIS_FINGER, v, h) } override fun onScrollEnd() { scrollRestX = 0f scrollRestY = 0f - BottomDesktop.sendScene(SCENE_AXIS, 0, 0) + BottomDesktop.sendScene(WaylandCompositor.SCENE_AXIS_FINGER, 0, 0) } override fun onZoom(steps: Int) { BottomDesktop.sendKey(KEY_LEFTCTRL, true) - BottomDesktop.sendScene(SCENE_WHEEL, steps) + BottomDesktop.sendScene(WaylandCompositor.SCENE_WHEEL, steps) BottomDesktop.sendKey(KEY_LEFTCTRL, false) } @@ -331,9 +332,6 @@ class BottomDesktopPanel( private fun dp(value: Int): Int = (value * resources.displayMetrics.density + 0.5f).toInt() private companion object { - const val SCENE_BUTTON = 3 - const val SCENE_WHEEL = 4 - const val SCENE_AXIS = 12 const val KEY_LEFTCTRL = 29 const val AXIS_UNITS_PER_PIXEL = 3f const val TEXT_FIELD_TAP_MS = 1_000L diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BottomGameScreen.kt b/app/src/main/java/com/droiddeck/launcher/ui/BottomGameScreen.kt index ba5b5af126..046142ad1d 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/BottomGameScreen.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/BottomGameScreen.kt @@ -19,6 +19,7 @@ class BottomGameScreen( display: Display, private val callback: SurfaceHolder.Callback, private val onTouch: (MotionEvent) -> Boolean, + private val onHover: (MotionEvent) -> Boolean, ) : Presentation(activity, display) { val surfaceView = SurfaceView(getContext()) val holder: SurfaceHolder get() = surfaceView.holder @@ -51,7 +52,7 @@ class BottomGameScreen( activity.dispatchKeyEvent(event) || super.dispatchKeyEvent(event) override fun dispatchGenericMotionEvent(event: MotionEvent): Boolean = - activity.dispatchGenericMotionEvent(event) || super.dispatchGenericMotionEvent(event) + onHover(event) || activity.dispatchGenericMotionEvent(event) || super.dispatchGenericMotionEvent(event) } object GameScreenSwap { diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndContent.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndContent.kt index 26d0506a73..610cd61138 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndContent.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndContent.kt @@ -212,6 +212,8 @@ internal fun inPane(o: Origin): Origin = private fun Backdrop(art: File?) { val colors = MaterialTheme.colorScheme val pal = LocalPalette.current + // True black keeps the page unlit: no art wash and no corner glow. + if (pal.id == Themes.TRUE_BLACK) return Crossfade(targetState = art, animationSpec = Motion.tw(700), label = "backdrop") { a -> if (a != null && Build.VERSION.SDK_INT >= 31) { Box(modifier = Modifier.fillMaxSize().alpha(0.26f).blur(70.dp)) { diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt index 6ae4c38762..cb5d228a7a 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt @@ -436,6 +436,7 @@ internal fun SetupPanel( } if (s.theme == Themes.INNER_GAMER) RgbSpeedRow() if (s.theme == Themes.GRADIENT) GradientColorRows() + if (s.theme == Themes.TRUE_BLACK) HighlightColorRow() ChoiceRow( host, "app-scale", stringResource(R.string.setup_app_scale), stringResource(R.string.setup_app_scale_hint), com.droiddeck.launcher.core.AppUiPrefs.scales.map { percent -> @@ -1177,6 +1178,16 @@ private fun RgbSpeedRow() { SliderRow(stringResource(R.string.theme_rgb_speed), stringResource(R.string.theme_rgb_speed_hint), Themes.rgbSpeed, 1..Themes.RGB_SPEEDS) { Themes.setRgbSpeed(ctx, it) } } +@Composable +private fun HighlightColorRow() { + val ctx = androidx.compose.ui.platform.LocalContext.current.applicationContext + val highlight = Themes.trueBlackHighlight + var picking by remember { mutableStateOf(false) } + val label = stringResource(R.string.theme_true_black_highlight) + SettingsRow(label, stringResource(R.string.theme_true_black_highlight_hint)) { ColorCube(androidx.compose.ui.graphics.Color(highlight), label) { picking = true } } + if (picking) ColorPickerDialog(label, highlight, onDismiss = { picking = false }) { argb -> Themes.setTrueBlackHighlight(ctx, argb) } +} + @Composable private fun GradientColorRows() { val ctx = androidx.compose.ui.platform.LocalContext.current.applicationContext diff --git a/app/src/main/java/com/droiddeck/launcher/ui/GlideWindows.kt b/app/src/main/java/com/droiddeck/launcher/ui/GlideWindows.kt index 36d4fcdd10..c13bebef13 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/GlideWindows.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/GlideWindows.kt @@ -1,17 +1,39 @@ package com.droiddeck.launcher.ui import androidx.compose.foundation.ScrollState +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.ColumnScope +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.widthIn import androidx.compose.foundation.rememberScrollState import androidx.compose.material3.AlertDialog import androidx.compose.material3.AlertDialogDefaults import androidx.compose.material3.DropdownMenu +import androidx.compose.material3.LocalContentColor +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.ProvideTextStyle +import androidx.compose.material3.Surface import androidx.compose.runtime.Composable +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.runtime.staticCompositionLocalOf +import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.Shape import androidx.compose.ui.unit.Dp import androidx.compose.ui.unit.DpOffset +import androidx.compose.ui.unit.IntOffset +import androidx.compose.ui.unit.IntRect +import androidx.compose.ui.unit.IntSize +import androidx.compose.ui.unit.LayoutDirection +import androidx.compose.ui.unit.dp import androidx.compose.ui.window.Dialog import androidx.compose.ui.window.DialogProperties import androidx.compose.ui.window.Popup @@ -41,13 +63,82 @@ internal fun TrackKeyWindow() { } } +internal val LocalPresentationWindow = staticCompositionLocalOf { false } + +private val OriginPosition = object : PopupPositionProvider { + override fun calculatePosition(anchorBounds: IntRect, windowSize: IntSize, layoutDirection: LayoutDirection, popupContentSize: IntSize) = IntOffset.Zero +} + +@Composable +internal fun WindowDialog( + onDismissRequest: () -> Unit, + properties: DialogProperties = DialogProperties(), + content: @Composable () -> Unit, +) { + if (!LocalPresentationWindow.current) { + Dialog(onDismissRequest, properties, content) + return + } + Popup( + OriginPosition, onDismissRequest, + PopupProperties(focusable = true, dismissOnBackPress = properties.dismissOnBackPress, dismissOnClickOutside = false, clippingEnabled = false), + ) { + Box( + Modifier.fillMaxSize().background(androidx.compose.ui.graphics.Color.Black.copy(alpha = 0.6f)) + .tapOutside { if (properties.dismissOnClickOutside) onDismissRequest() }, + contentAlignment = Alignment.Center, + ) { content() } + } +} + @Composable internal fun GlideDialog( onDismissRequest: () -> Unit, properties: DialogProperties = DialogProperties(), content: @Composable () -> Unit, ) { - Dialog(onDismissRequest, properties) { TrackKeyWindow(); FocusGlideHost(content = content) } + WindowDialog(onDismissRequest, properties) { TrackKeyWindow(); FocusGlideHost(content = content) } +} + +@Composable +private fun PresentationAlert( + confirmButton: @Composable () -> Unit, + modifier: Modifier, + dismissButton: (@Composable () -> Unit)?, + icon: (@Composable () -> Unit)?, + title: (@Composable () -> Unit)?, + text: (@Composable () -> Unit)?, + shape: Shape, + containerColor: Color, + iconContentColor: Color, + titleContentColor: Color, + textContentColor: Color, + tonalElevation: Dp, +) { + Surface(modifier.blockTouches().padding(24.dp).widthIn(min = 280.dp, max = 560.dp), shape, containerColor, tonalElevation = tonalElevation) { + Column(Modifier.padding(24.dp)) { + icon?.let { + Box(Modifier.align(Alignment.CenterHorizontally)) { CompositionLocalProvider(LocalContentColor provides iconContentColor, content = it) } + Spacer(Modifier.height(16.dp)) + } + title?.let { + ProvideTextStyle(MaterialTheme.typography.headlineSmall) { + CompositionLocalProvider(LocalContentColor provides titleContentColor, content = it) + } + Spacer(Modifier.height(16.dp)) + } + text?.let { + ProvideTextStyle(MaterialTheme.typography.bodyMedium) { + CompositionLocalProvider(LocalContentColor provides textContentColor, content = it) + } + Spacer(Modifier.height(24.dp)) + } + Row(Modifier.align(Alignment.End), horizontalArrangement = Arrangement.spacedBy(8.dp)) { + dismissButton?.invoke() + confirmButton() + } + } + } } @Composable @@ -81,7 +172,13 @@ internal fun GlideAlertDialog( properties: DialogProperties = DialogProperties(), ) { FocusGlideWindow { overlay -> - AlertDialog( + if (LocalPresentationWindow.current) WindowDialog(onDismissRequest, properties) { + TrackKeyWindow() + PresentationAlert( + confirmButton, modifier.then(overlay), dismissButton, icon, title, text, + shape, containerColor, iconContentColor, titleContentColor, textContentColor, tonalElevation, + ) + } else AlertDialog( onDismissRequest, confirmButton, modifier.then(overlay), dismissButton, icon, title, text, shape, containerColor, iconContentColor, titleContentColor, textContentColor, tonalElevation, properties, ) diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt index 70fd435c94..4c882ab1e9 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt @@ -63,6 +63,7 @@ class ModeSettings( val upscaler: Int = 0, val upscaleSharpness: Int = 75, val touchMode: String, + val pen: SessionPrefs.Pen? = null, val suspendPolicy: String, val steamDownloadsInBackground: Boolean = false, val pipSupported: Boolean = false, @@ -116,6 +117,7 @@ class ModeSettingsActions( val onUpscaler: (Int) -> Unit = {}, val onUpscaleSharpness: (Int) -> Unit = {}, val onTouch: (String) -> Unit, + val onPen: (key: String, value: String) -> Unit = { _, _ -> }, val onSuspendPolicy: (String) -> Unit, val onSteamDownloadsInBackground: (Boolean) -> Unit = {}, val onPipAutoEnter: (Boolean) -> Unit = {}, @@ -321,6 +323,7 @@ fun ModeSheetRows(s: ModeSettings, a: ModeSettingsActions, tab: String, extras: } PhysicalShortcutRows() } + s.pen?.let { PenSettingsGroup(host, it, onPick = a.onPen) } } if (tab == SheetTab.AUDIO && steam) { if (s.directAudio != null && s.mic != null) SettingsGroup(stringResource(R.string.mode_audio)) { diff --git a/app/src/main/java/com/droiddeck/launcher/ui/PenSettingsGroup.kt b/app/src/main/java/com/droiddeck/launcher/ui/PenSettingsGroup.kt new file mode 100644 index 0000000000..646c8cfcc6 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/ui/PenSettingsGroup.kt @@ -0,0 +1,25 @@ +package com.droiddeck.launcher.ui + +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import com.droiddeck.launcher.R +import com.droiddeck.launcher.session.SessionPrefs + +@Composable +internal fun PenSettingsGroup( + host: MenuHost, pen: SessionPrefs.Pen, track: (String) -> Modifier = { Modifier }, + onPick: (key: String, value: String) -> Unit, +) { + SettingsGroup(stringResource(R.string.mode_pen)) { + ChoiceRow(host, "pen", stringResource(R.string.mode_pen), null, + listOf(SessionPrefs.PEN_MOUSE to stringResource(R.string.mode_pen_mouse), + SessionPrefs.PEN_TOUCH to stringResource(R.string.mode_pen_touch)), + pen.mode, chipModifier = track("pen")) { onPick("pen", it) } + if (pen.mode != SessionPrefs.PEN_TOUCH) ChoiceRow(host, "pen-button", stringResource(R.string.mode_pen_button), null, + listOf(SessionPrefs.PEN_BUTTON_RIGHT to stringResource(R.string.gesture_right_click), + SessionPrefs.PEN_BUTTON_MIDDLE to stringResource(R.string.gesture_middle_click), + SessionPrefs.PEN_BUTTON_OFF to stringResource(R.string.widgets_off)), + pen.button, chipModifier = track("pen-button")) { onPick("penButton", it) } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/PerformanceDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/PerformanceDialog.kt index fdfd5ca3d2..e55590dba3 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/PerformanceDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/PerformanceDialog.kt @@ -49,6 +49,7 @@ fun PerformancePage( gpuClockPin: Boolean, ramCapMb: Int, zramClient: Boolean, + zramIdle: Boolean, vramCapMb: Int, deviceRamMb: Int, ramCapAvailable: Boolean, @@ -72,6 +73,7 @@ fun PerformancePage( onGpuClockPin: (Boolean) -> Unit, onRamCapMb: (Int) -> Unit, onZramClient: (Boolean) -> Unit, + onZramIdle: (Boolean) -> Unit, onVramCapMb: (Int) -> Unit, onProotNoSeccomp: (Boolean) -> Unit, onProotFastPath: (Boolean) -> Unit, @@ -146,6 +148,11 @@ fun PerformancePage( val top = (deviceRamMb / MEMORY_CAP_STEP_MB * MEMORY_CAP_STEP_MB).coerceAtLeast(MEMORY_CAP_STEP_MB) val off = stringResource(R.string.perf_cap_off) val auto = stringResource(R.string.perf_cap_auto) + ToggleRow( + host, "zramidle", stringResource(R.string.perf_zram_idle), + if (ramCapAvailable) stringResource(R.string.perf_zram_idle_hint) else stringResource(R.string.perf_ram_cap_unavailable), + zramIdle && ramCapAvailable, enabled = ramCapAvailable, onChange = onZramIdle, + ) ToggleRow( host, "zramclient", stringResource(R.string.perf_zram_client), if (ramCapAvailable) stringResource(R.string.perf_zram_client_hint) else stringResource(R.string.perf_ram_cap_unavailable), diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt b/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt index d9a4967d76..578c936ad6 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt @@ -143,7 +143,7 @@ class SecondScreenPresentation( val view = androidx.compose.ui.platform.ComposeView(context).apply { isFocusable = true isFocusableInTouchMode = true - setContent { content() } + setContent { PresentationWindows(content) } } chatView = view root.addView(view, 1.coerceAtMost(root.childCount), LinearLayout.LayoutParams(-1, -2)) @@ -179,7 +179,7 @@ class SecondScreenPresentation( isFocusable = true isFocusableInTouchMode = true defaultFocusHighlightEnabled = false - setContent { content() } + setContent { PresentationWindows(content) } frame.addView(this, FrameLayout.LayoutParams(-1, -1)) menuView = this } @@ -340,7 +340,7 @@ class SecondScreenPresentation( private fun renderDashboard() { val content = dashboard ?: return bar(SecondScreenMode.DASHBOARD) - val view = androidx.compose.ui.platform.ComposeView(context).apply { setContent { content() } } + val view = androidx.compose.ui.platform.ComposeView(context).apply { setContent { PresentationWindows(content) } } dashboardView = view root.addView(view, weightParams()) } @@ -364,7 +364,7 @@ class SecondScreenPresentation( private fun renderTerminal() { bar(SecondScreenMode.TERMINAL) - val panel = SessionTerminalPanel(context) + val panel = SessionTerminalPanel(context, keepShell = true) terminalPanel = panel root.addView(panel, weightParams()) } @@ -388,3 +388,8 @@ class SecondScreenPresentation( or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION) } } + +@androidx.compose.runtime.Composable +private fun PresentationWindows(content: @androidx.compose.runtime.Composable () -> Unit) { + androidx.compose.runtime.CompositionLocalProvider(LocalPresentationWindow provides true) { content() } +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt index 2e57de51cf..7174fd8b25 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt @@ -239,10 +239,15 @@ class DrawerActions( val onPadType: (String) -> Unit = {}, val touchMode: String, val touchAuto: String, + val pen: SessionPrefs.Pen? = null, + val onPen: (key: String, value: String) -> Unit = { _, _ -> }, val fexPreset: String, val upscaler: Int = 0, val upscaleSharpness: Int = 75, val effects: ScreenEffects = ScreenEffects.OFF, + val screenEffectsTarget: String = "auto", + val screenEffectsTargets: List> = emptyList(), + val screenEffectsCanDelete: Boolean = false, val cardboard: Cardboard = Cardboard.OFF, val cardboardSensor: Boolean = false, val steamVr: SteamVr.Status? = null, @@ -304,8 +309,13 @@ class DrawerActions( val onDirectHoldBehavior: (String) -> Unit = {}, val onFexPreset: (String) -> Unit, val onUpscaler: (Int) -> Unit = {}, + val onPresetUpscaler: (Int) -> Unit = onUpscaler, val onUpscaleSharpness: (Int) -> Unit = {}, val onEffects: (ScreenEffects) -> Unit = {}, + val onScreenEffectsTarget: (String) -> Unit = {}, + val onScreenEffectsReset: () -> Unit = {}, + val onScreenEffectsDelete: () -> Unit = {}, + val onScreenEffectsProfilesRefresh: () -> Unit = {}, val onCardboard: (Cardboard) -> Unit = {}, val onCardboardRecenter: () -> Unit = {}, val onGlassesRecenter: () -> Unit = {}, @@ -422,6 +432,9 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont } } } + LaunchedEffect(open, page) { + if (open && page == SessionDrawerPage.EFFECTS) a.onScreenEffectsProfilesRefresh() + } LaunchedEffect(open, controllerActive) { if (open && !controllerActive) focusManager.clearFocus(force = true) } @@ -661,6 +674,7 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont onPick = a.onDirectHoldBehavior) } } + a.pen?.let { PenSettingsGroup(host, it, track = { key -> focus.track(page, key) }, onPick = a.onPen) } SettingsGroup(stringResource(R.string.input_screen_visibility)) { ChoiceRow(host, "osc", stringResource(R.string.mode_osc), null, if (a.steam) listOf(SessionPrefs.OSC_AUTO to stringResource(R.string.common_auto), SessionPrefs.OSC_ALWAYS to stringResource(R.string.common_always), SessionPrefs.OSC_STEAM_TOUCH to stringResource(R.string.osc_steam_touch), SessionPrefs.OSC_STEAM_QAM to stringResource(R.string.mode_osc_qam), SessionPrefs.OSC_NEVER to stringResource(R.string.common_never)) @@ -1064,12 +1078,32 @@ private fun ScreenEffectsGroup( val colors = MaterialTheme.colorScheme val pal = LocalPalette.current SettingsGroup(stringResource(R.string.drawer_effects)) { + ChoiceRow( + host, "effects-profile", stringResource(R.string.screen_effects_target), + stringResource(R.string.screen_effects_target_hint), a.screenEffectsTargets, + a.screenEffectsTarget, chipModifier = track("effects-profile"), + onPick = a.onScreenEffectsTarget, + ) + ActionRow( + stringResource(R.string.screen_effects_reset), + stringResource(R.string.screen_effects_reset_hint), + stringResource(R.string.hud_reset_button), + a.onScreenEffectsReset, + modifier = track("effects-reset"), + ) + if (a.screenEffectsCanDelete) ActionRow( + stringResource(R.string.screen_effects_delete), + stringResource(R.string.screen_effects_delete_hint), + stringResource(R.string.common_delete), + a.onScreenEffectsDelete, + modifier = track("effects-delete"), + ) val presets = ScreenEffectLooks.LOOKS.map { it.name to stringResource(it.label) } ChoiceRow(host, "look", stringResource(R.string.drawer_look), null, if (preset == null) listOf(LOOK_CUSTOM to stringResource(R.string.drawer_look_custom)) + presets else presets, preset?.name ?: LOOK_CUSTOM, chipModifier = track("look")) { name -> ScreenEffectLooks.LOOKS.firstOrNull { it.name == name }?.let { picked -> - picked.scalingMode?.let(a.onUpscaler) + picked.scalingMode?.let(a.onPresetUpscaler) a.onEffects(picked.effects) } } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SessionPanels.kt b/app/src/main/java/com/droiddeck/launcher/ui/SessionPanels.kt index 35d5538bfb..a3e196c2ac 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SessionPanels.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionPanels.kt @@ -21,7 +21,7 @@ import com.termux.terminal.TerminalSessionClient import com.termux.view.TerminalView import com.termux.view.TerminalViewClient -class SessionTerminalPanel(context: Context) : LinearLayout(context) { +class SessionTerminalPanel(context: Context, private val keepShell: Boolean = false) : LinearLayout(context) { private var terminalSession: TerminalSession? = null private var terminalView: TerminalView? = null private var terminalPid = -1 @@ -45,7 +45,8 @@ class SessionTerminalPanel(context: Context) : LinearLayout(context) { isFocusableInTouchMode = true } terminalView = view - val session = SessionTerminal.create(terminalClient) + val session = (if (keepShell) SessionTerminal.reuse(terminalClient) else null) + ?: SessionTerminal.create(terminalClient)?.also { if (keepShell) SessionTerminal.keep(it) } if (session == null) { addView(TextView(context).apply { text = context.getString(R.string.second_terminal_not_ready) @@ -82,6 +83,7 @@ class SessionTerminalPanel(context: Context) : LinearLayout(context) { key("→", "\u001b[C") key(context.getString(R.string.second_key_ctrl_c), "\u0003") key(context.getString(R.string.second_key_ctrl_d), "\u0004") + key(context.getString(R.string.second_key_clear), "\u000c") keyStrip.addView(keys) addView(keyStrip, LayoutParams(-1, -2)) @@ -121,8 +123,12 @@ class SessionTerminalPanel(context: Context) : LinearLayout(context) { (context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager) .hideSoftInputFromWindow(view.windowToken, 0) } - val pid = terminalPid.takeIf { it > 1 } ?: (terminalSession?.pid ?: -1) - if (pid > 1) SessionService.stopTerminalProcess(context, pid) + val session = terminalSession + if (!keepShell || session?.isRunning != true) { + val pid = terminalPid.takeIf { it > 1 } ?: (session?.pid ?: -1) + if (pid > 1) SessionService.stopTerminalProcess(context, pid) + SessionTerminal.release(session) + } terminalPid = -1 terminalSession = null terminalView = null @@ -140,6 +146,7 @@ class SessionTerminalPanel(context: Context) : LinearLayout(context) { override fun onSessionFinished(finishedSession: TerminalSession) { val pid = terminalPid.takeIf { it > 1 } ?: finishedSession.pid if (pid > 1) SessionService.terminalProcessExited(context, pid) + SessionTerminal.release(finishedSession) terminalPid = -1 terminalView?.onScreenUpdated() } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/Theme.kt b/app/src/main/java/com/droiddeck/launcher/ui/Theme.kt index 2e2c1049e4..6b4dd7d99a 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/Theme.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/Theme.kt @@ -59,6 +59,11 @@ object Themes { const val DEFAULT_RGB_SPEED = 3 const val RGB_HUE_STEP = 3f const val WHITE_RED = "white_red" + const val TRUE_BLACK = "true_black" + const val DEFAULT_HIGHLIGHT = 0xFF1A9FFF.toInt() + + var trueBlackHighlight by mutableStateOf(DEFAULT_HIGHLIGHT) + private set var rgbSpeed by mutableStateOf(DEFAULT_RGB_SPEED) private set @@ -81,6 +86,12 @@ object Themes { fun loadGradient(context: Context) { gradientColors = SessionPrefs.gradientColors(context) rgbSpeed = SessionPrefs.rgbSpeed(context) + trueBlackHighlight = SessionPrefs.trueBlackHighlight(context) + } + + fun setTrueBlackHighlight(context: Context, highlight: Int) { + SessionPrefs.setTrueBlackHighlight(context, highlight) + trueBlackHighlight = highlight } fun innerGamer(hue: Float): Palette = ThemeColors.palette( @@ -95,7 +106,7 @@ object Themes { fun current(context: Context): Palette { val id = SessionPrefs.theme(context) - if (id == GRADIENT || id == INNER_GAMER) loadGradient(context) + if (id == GRADIENT || id == INNER_GAMER || id == TRUE_BLACK) loadGradient(context) return byId(id) } @@ -128,6 +139,7 @@ object Themes { primary = Color(0xFF2E86FF), primary2 = Color(0xFF2684FF), onPrimary = Color(0xFF03111F), signal = Color(0xFF2E86FF), good = Color(0xFF4CD37F), ), + ThemeColors.trueBlack(DEFAULT_HIGHLIGHT), Palette( WHITE_RED, R.string.theme_white_red, R.string.theme_white_red_detail, background = Color(0xFFF8F8F8), surface = Color(0xFFFFFFFF), surfaceVariant = Color(0xFFF0F0F0), line = Color(0xFFDDDDDD), line2 = Color(0xFFC8C8C8), @@ -141,6 +153,7 @@ object Themes { fun byId(id: String): Palette { if (id == INNER_GAMER) return innerGamer(rgbHue) + if (id == TRUE_BLACK) return ThemeColors.trueBlack(trueBlackHighlight) if (id == GRADIENT) return ThemeColors.palette(gradientColors.first, gradientColors.second, R.string.theme_gradient, R.string.theme_gradient_detail) return all.firstOrNull { it.id == id } ?: all[0] } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ThemeColors.kt b/app/src/main/java/com/droiddeck/launcher/ui/ThemeColors.kt index 938d2ef90a..279941154f 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/ThemeColors.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/ThemeColors.kt @@ -3,6 +3,7 @@ package com.droiddeck.launcher.ui import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.luminance import androidx.compose.ui.graphics.toArgb +import com.droiddeck.launcher.R import kotlin.math.max import kotlin.math.min import kotlin.math.roundToInt @@ -147,4 +148,18 @@ internal object ThemeColors { good = Color(0xFF4CD37F), ) } + + // Page and panels are pure black so an OLED panel leaves those pixels off; only raised cards, rules and the highlight are lit. + fun trueBlack(highlight: Int): Palette { + val seen = readable(highlight) + val ink = inkFor(seen, seen) + val accent = Color(fitTo(ink, seen)) + return Palette( + Themes.TRUE_BLACK, R.string.theme_true_black, R.string.theme_true_black_detail, + background = Color.Black, surface = Color.Black, surfaceVariant = Color(0xFF0C0C0D), line = Color(0xFF1C1D20), line2 = Color(0xFF2A2C30), + onBackground = Color(0xFFF2F4F7), onSurfaceVariant = Color(0xFF8E9196), + primary = accent, primary2 = accent, onPrimary = ink, signal = accent, + good = Color(0xFF4CD37F), + ) + } } diff --git a/app/src/main/java/com/droiddeck/launcher/update/SelfInstaller.kt b/app/src/main/java/com/droiddeck/launcher/update/SelfInstaller.kt index 5d1d33455c..7e0992433c 100644 --- a/app/src/main/java/com/droiddeck/launcher/update/SelfInstaller.kt +++ b/app/src/main/java/com/droiddeck/launcher/update/SelfInstaller.kt @@ -90,10 +90,11 @@ object SelfInstaller { } } - fun install(context: Context, apk: File, onSession: (Int) -> Unit = {}) { + fun install(context: Context, apk: File, packageName: String = context.packageName, action: String = ACTION_STATUS, + onSession: (Int) -> Unit = {}) { val installer = context.packageManager.packageInstaller val params = PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL).apply { - setAppPackageName(context.packageName) + setAppPackageName(packageName) setSize(apk.length()) if (Build.VERSION.SDK_INT >= 31) setRequireUserAction(PackageInstaller.SessionParams.USER_ACTION_NOT_REQUIRED) } @@ -105,7 +106,7 @@ object SelfInstaller { session.fsync(out) } } - val status = Intent(ACTION_STATUS).setPackage(context.packageName) + val status = Intent(action).setPackage(context.packageName) val flags = PendingIntent.FLAG_UPDATE_CURRENT or (if (Build.VERSION.SDK_INT >= 31) PendingIntent.FLAG_MUTABLE else 0) onSession(id) session.commit(PendingIntent.getBroadcast(context, id, status, flags).intentSender) diff --git a/app/src/main/java/com/droiddeck/launcher/wayland/CompositorHost.kt b/app/src/main/java/com/droiddeck/launcher/wayland/CompositorHost.kt index 7fcdc09620..3a47cfeaa3 100644 --- a/app/src/main/java/com/droiddeck/launcher/wayland/CompositorHost.kt +++ b/app/src/main/java/com/droiddeck/launcher/wayland/CompositorHost.kt @@ -64,6 +64,7 @@ object CompositorHost { com.droiddeck.launcher.gpu.TpUbwcHint.applyToProcess(context) WaylandCompositor.nativeStartWithSurface( surface, xdgRuntimeDir, driverPath, libraryName, nativeLibDir, + SessionPrefs.androidDriver(context).isEmpty(), ) attached = surface started = true diff --git a/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java b/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java index 10735a1710..39c37f0a47 100644 --- a/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java +++ b/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java @@ -153,7 +153,7 @@ public final class WaylandCompositor { public static native void nativeStartWithSurface(Surface surface, String xdgRuntimeDir, String driverPath, String libraryName, - String nativeLibDir); + String nativeLibDir, boolean allowDriverFallback); public static native void nativeSetSurface(Surface surface); public static native boolean nativeWaitSurface(int timeoutMs); @@ -162,6 +162,8 @@ public final class WaylandCompositor { public static native void nativeSendTouch(int action, int pointerId, int x, int y); + public static native void nativeSendPen(int flags, int x, int y); + public static native int nativeCursorSnapshot(int[] out); public static native int nativeCursorSerial(); @@ -238,6 +240,8 @@ public final class WaylandCompositor { public static native boolean nativeGamePictureRect(float[] out); + public static native boolean nativeOutputSize(int[] out); + public static native void nativeResizeOutput(int width, int height); public static native void nativeResetFirstFrame(); @@ -325,6 +329,9 @@ public final class WaylandCompositor { public static native void nativeSendSceneInput(int type, int a, int b); + public static final int SCENE_BUTTON = 3, SCENE_WHEEL = 4, SCENE_POINTER_DELTA = 6, SCENE_AXIS = 11, SCENE_AXIS_FINGER = 12; + public static final int WHEEL_STEP_UNITS = 120, POINTER_DELTA_SCALE = 256; + public static final int FG_ENGINE_LSFG = 0, FG_ENGINE_DDFG = 1; public static native void nativeSetFrameGenEngine(int kind); @@ -353,19 +360,19 @@ public final class WaylandCompositor { public static void sendPointerDelta(int dx, int dy) { if (dx == 0 && dy == 0) return; - nativeSendSceneInput(6, dx * 256, dy * 256); + nativeSendSceneInput(SCENE_POINTER_DELTA, dx * POINTER_DELTA_SCALE, dy * POINTER_DELTA_SCALE); } private static float pendingDeltaX, pendingDeltaY; public static void sendPointerDelta(float dx, float dy) { - pendingDeltaX += dx * 256f; - pendingDeltaY += dy * 256f; + pendingDeltaX += dx * POINTER_DELTA_SCALE; + pendingDeltaY += dy * POINTER_DELTA_SCALE; int x = (int) Math.floor(pendingDeltaX); int y = (int) Math.floor(pendingDeltaY); if (x == 0 && y == 0) return; pendingDeltaX -= x; pendingDeltaY -= y; - nativeSendSceneInput(6, x, y); + nativeSendSceneInput(SCENE_POINTER_DELTA, x, y); } } diff --git a/app/src/main/res/values-ar/strings.xml b/app/src/main/res/values-ar/strings.xml index 191f4a79e3..89fe618284 100644 --- a/app/src/main/res/values-ar/strings.xml +++ b/app/src/main/res/values-ar/strings.xml @@ -9,15 +9,35 @@ تعذّر على DroidDeck إعادة التشغيل تلقائيًا. أغلق التطبيق تمامًا، ثم أعد فتحه. DroidDeck - يُنزَّل Steam عند التشغيل الأول. قد يستغرق ذلك بضع دقائق. - افتراضيًا، يؤدي الخروج من التطبيق إلى إيقاف Steam مؤقتًا، ويُستأنف من حيث توقف عند عودتك. - تظهر وحدة التحكم لديك كوحدة تحكم Xbox 360. وإلا، فاستخدم عناصر التحكم على الشاشة. + يقوم التشغيل الأول بتنزيل Steam. قد يستغرق ذلك بضع دقائق. + تظهر وحدة التحكم لديك في Steam على أنها وحدة تحكم Steam Deck. بدّلها إلى Steam Controller أو DualShock 4 أو DualSense أو Xbox 360 من إعدادات الجلسة، ويُطبَّق ذلك في الجلسة التالية. + اضغط مطوّلًا على الرجوع في وحدة التحكم لفتح قائمة الوصول السريع في Steam. يجب تفعيل «الضغط المطوّل على الرجوع لاختصارات Steam» في إعدادات الجلسة. + يحدد «السلوك في الخلفية» ما يحدث عند مغادرة التطبيق: «أصلي» يجهّز Steam للسكون، و«تلقائي» يوقفه مؤقتًا، و«يدوي» ينتظر «استئناف»، و«أبدًا» يُبقيه قيد التشغيل. + تستخدم ألعاب Steam «حد الإطارات» من Steam في الوصول السريع. تنتقل الشاشة إلى معدل تحديث يقبل الحد القسمة عليه بالتساوي إن وُجد. + يرسل «وضع زمن الاستجابة المنخفض» في قائمة الجلسة إدخال وحدة التحكم بتردد 1000 هرتز بدلًا من 250 هرتز، مقابل استهلاك أكبر قليلًا للمعالج والبطارية. + لكل لعبة ملفها الشخصي الخاص مع إعدادات Proton وFEX والمكوّنات والبيئة. + تضم قائمة الجلسة مفتاح الميكروفون للدردشة الصوتية وزر «تعليق الآن» لتجميد الجلسة عند الطلب. + اسحب DroidDeck HUD لتحريكه، واضغط بإصبعين لتغيير حجمه، وادفعه نحو حافة الشاشة لتثبيته كعلامة تبويب صغيرة لمعدل الإطارات. + في الأجهزة المحمولة ذات الشاشتين، يمكن للشاشة السفلية عرض التنزيلات والإشعارات ولقطات الشاشة ودردشة Steam. يضع «تبديل الشاشات» اللعبة هناك بدلًا من ذلك. + أضف مكتبات Steam من بطاقة SD أو محرك USB أو SSD، وسيجمع DroidDeck الألعاب معًا في «المكتبة». + تتيح لك «المتاجر» تسجيل الدخول إلى Epic Games وGOG وXbox وEA وBattle.net وUbisoft Connect وAmazon Games وitch.io وGame Jolt، ثم تثبيت ألعابها وتحديثها من DroidDeck. + تحدّث المكوّنات مثل FEX وDXVK وVKD3D-Proton نفسها تلقائيًا، ويكون Proton Experimental ARM64 هو الافتراضي، أو Proton 11.0 ARM64 بعد تثبيت هذا الإصدار. + يحرر «ضغط Steam أثناء تشغيل لعبة» مساحة من الذاكرة في الأجهزة قليلة الذاكرة. + اسحب من الحافة اليمنى للداخل لفتح قائمة الجلسة: وضع «لوحة اللمس» و«لوحة مفاتيح الكمبيوتر» و«وضع زمن الاستجابة المنخفض» وملف اللعبة والمزيد. + اللعبة بطيئة؟ حدّد معدل الإطارات في الوصول السريع، ثم جرّب إصدار Proton آخر أو إعدادًا مسبقًا آخر لـ FEX في مكوّنات اللعبة. + هل الصوت متقطع أو مفقود في اللعبة؟ جرّب مفتاح «DirectAudio للألعاب» في إعدادات Steam ضمن «الصوت». + يمكن لـ«الإعداد» ثم «التخزين» مسح ذاكرات التظليل المؤقتة وبقايا البادئات من الألعاب التي أزلتها. + واجهت خطأً؟ يجمع «مشاركة السجلات» في قائمة الجلسة بيانات التشخيص. انشرها في #bug-reports على Discord. - يُعَدّ سطح المكتب عند التشغيل الأول. قد يستغرق ذلك بضع دقائق. - افتراضيًا، يؤدي الخروج من التطبيق إلى إيقاف الجلسة مؤقتًا، وتُستأنف من حيث توقفت عند عودتك. - يعمل اللمس كلوحة لمس: اسحب لتحريك المؤشر، وانقر لتنفيذ نقرة. - تظهر وحدة التحكم لديك كوحدة تحكم Xbox 360. وإلا، فاستخدم عناصر التحكم على الشاشة. + يقوم التشغيل الأول بإعداد سطح المكتب. قد يستغرق ذلك بضع دقائق. + يعمل اللمس كلوحة لمس: اسحب لتحريك المؤشر، وانقر للنقر. + يحدد «السلوك في الخلفية» ما يحدث عند مغادرة التطبيق: «يدوي» ينتظر «استئناف» افتراضيًا، و«تلقائي» يوقف مؤقتًا، و«أبدًا» يُبقيه قيد التشغيل. + اسحب من الحافة اليمنى للداخل لفتح قائمة الجلسة، ثم اختر «لوحة مفاتيح الكمبيوتر» للكتابة في التطبيقات التي تتجاهل لوحة مفاتيح Android. + تتيح «لوحة مفاتيح الكمبيوتر» في قائمة الجلسة ضبط الحجم والشفافية ومجموعات المفاتيح. + تظهر وحدة التحكم لديك كوحدة تحكم Xbox 360. وإلا فاستخدم عناصر التحكم على الشاشة. + تضم قائمة الجلسة مفتاح الميكروفون وزر «تعليق الآن» لتجميد الجلسة عند الطلب. + واجهت خطأً؟ يجمع «مشاركة السجلات» في قائمة الجلسة بيانات التشخيص. انشرها في #bug-reports على Discord. الجلسة يظهر أثناء فتح جلسة Steam أو جلسة سطح المكتب @@ -269,6 +289,10 @@ لوحة اللمس مباشر تلقائي: لوحة لمس على سطح المكتب، ولمس مباشر في Steam. + القلم + الفأرة + اللمس + الزر الجانبي عناصر التحكم على الشاشة Steam + QAM يعرض الخيار «تلقائي» عناصر التحكم عند عدم توصيل وحدة تحكم. @@ -612,6 +636,8 @@ إيقاف افتراضي برنامج التشغيل ضغط Steam أثناء تشغيل لعبة + ضغط ذاكرة اللعبة الخاملة + يرحّل ذاكرة اللعبة الخاملة عند انخفاض RAM. أوقفه إذا كانت الألعاب تتجمد لبضع ثوانٍ كل نصف دقيقة تقريبًا. يُطبَّق عند بدء الجلسة التالية. بعد 20 ثانية من بدء اللعبة، يُضغط عميل Steam في zRAM لترك ذاكرة أكبر للعبة، ثم يُقرأ مجددًا عند إغلاقها. أوقف هذا الخيار إذا كانت الجلسة تُغلَق بعد بدء الألعاب بقليل. يظل حد RAM أعلاه يضغط Steam عندما تتجاوزه الجلسة. حد RAM يُطبَّق أثناء تشغيل عميل Steam، في جلسة Steam أو من سطح المكتب. عندما تستخدم الجلسة أكثر من هذا الحد، يُضغط Steam ثم عمليات الجلسة المدعومة الأخرى في zRAM. حد مرن: لا يُغلَق شيء، لكن قد تتقطّع الألعاب أثناء استعادة الصفحات. @@ -622,7 +648,7 @@ لـ Adreno فقط. تقطّع أقل، مع استهلاك أكبر للبطارية والحرارة. إصلاحات الجلسة Turnip: التصيير عبر sysmem - أسرع لعميل Steam؛ في الألعاب يختار برنامج التشغيل بين العرض المقسّم إلى مربعات والعرض في ذاكرة النظام لكل مرحلة. مطلوب على Adreno 710/720/722. + ينطبق على عميل Steam والألعاب. مطلوب على Adreno 710/720/722. تجاوز مساعد xalia في Steam droiddeck-ntsync بديل في مساحة المستخدم لبرنامج تشغيل ntsync في Linux. أثناء تفعيله، يستخدمه Proton بدلًا من droiddeck-esync وdroiddeck-fsync. يعمل مع Proton Experimental ARM64 وGE-Proton وproton-cachyos. يُطبَّق في الجلسة التالية. @@ -1910,6 +1936,7 @@ %1$s ✓ Ctrl+C Ctrl+D + مسح ثبِّت بيئة التشغيل أولاً مكتبة Steam غير متاحة مكتبة SD السابقة غير متاحة @@ -3993,8 +4020,6 @@ يبقى Alt+Tab ومفتاح Win وزر الرئيسية داخل الجلسة غير متاح في Android؟ معلومات التطبيق → ⋮ → السماح بالإعدادات المحظورة محظور من Android · معلومات التطبيق → ⋮ → السماح بالإعدادات المحظورة - مفاتيح نظام DroidDeck - إبقاء Alt+Tab ومفتاح Win وزر الرئيسية داخل جلسة DroidDeck النشطة بدلاً من Android. فعّل «السطوع» من الإعداد → تكامل Steam جسر Mali: متوقف لا يمكن لـ %1$s استخدام جسر Mali (يحتاج إلى معالج رسوميات Mali من دون مسار لبرنامج تشغيل النظام)، لذا ليس لهذا المفتاح أي تأثير هنا. @@ -4159,10 +4184,11 @@ إعادة تعيين المواضع إظهار التسمية تعذّر استيراد هذا التخطيط + يُثبّت عبر %1$s ثلج قرمزي أسطح بيضاء مع لمسات حمراء. - + الموسيقى التصويرية الموسيقى خيارات التشغيل diff --git a/app/src/main/res/values-b+es+419/strings.xml b/app/src/main/res/values-b+es+419/strings.xml index c892f88c8e..2e52a73788 100644 --- a/app/src/main/res/values-b+es+419/strings.xml +++ b/app/src/main/res/values-b+es+419/strings.xml @@ -9,15 +9,35 @@ DroidDeck no pudo reiniciarse automáticamente. Cierra la app por completo y vuelve a abrirla. DroidDeck - La primera vez se descarga Steam. Puede tardar unos minutos. - De forma predeterminada, al salir de la app Steam se pausa y continúa donde lo dejaste cuando vuelves. - Tu control aparece como un control de Xbox 360. Si no, usa los controles en pantalla. + La primera ejecución descarga Steam. Puede tardar unos minutos. + Tu control aparece en Steam como un control de Steam Deck. Cámbialo a Steam Controller, DualShock 4, DualSense o Xbox 360 en los ajustes de la sesión; se aplica en la próxima sesión. + Mantén Atrás en tu control para abrir el menú Quick Access de Steam. «Mantener Atrás para atajos de Steam» debe estar activado en los ajustes de la sesión. + Comportamiento en segundo plano decide qué pasa al salir de la app: Nativo prepara Steam para suspenderse, Auto lo pausa, Manual espera a Reanudar y Nunca lo mantiene en ejecución. + Los juegos de Steam usan el Límite de fotogramas de Steam en Quick Access. La pantalla cambia a una frecuencia de actualización que el límite divida exactamente, si existe. + El Modo de baja latencia del menú de sesión envía la entrada del control a 1000 Hz en lugar de 250 Hz, a cambio de un poco más de CPU y batería. + Cada juego tiene su propio perfil con Proton, FEX, componentes y ajustes de entorno. + El menú de sesión tiene un interruptor de micrófono para el chat de voz y un botón Suspender ahora para congelar la sesión cuando quieras. + Arrastra el HUD de DroidDeck para moverlo, pellizca para cambiar su tamaño y empújalo contra un borde para acoplarlo como una pequeña pestaña de FPS. + En consolas portátiles de doble pantalla, la pantalla inferior puede mostrar descargas, notificaciones, capturas de pantalla y el chat de Steam. Intercambiar pantallas pone el juego allí. + Añade bibliotecas de Steam desde una tarjeta SD, una unidad USB o un SSD, y DroidDeck mantiene los juegos juntos en tu Biblioteca. + Tiendas te permite iniciar sesión en Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io y Game Jolt, y luego instalar y actualizar sus juegos desde DroidDeck. + Componentes como FEX, DXVK y VKD3D-Proton se actualizan solos, y Proton Experimental ARM64 es el predeterminado, o Proton 11.0 ARM64 una vez instalada esa versión. + Comprimir Steam mientras se ejecuta un juego libera RAM en dispositivos con poca memoria. + Desliza desde el borde derecho para abrir el menú de sesión: modo touchpad, Teclado de PC, Modo de baja latencia, perfil del juego y más. + ¿El juego va lento? Limita la tasa de fotogramas en Quick Access y prueba otra versión de Proton o un ajuste preestablecido de FEX en los componentes del juego. + ¿Audio del juego entrecortado o ausente? Prueba el interruptor DirectAudio para juegos en los ajustes de Steam, en Audio. + Configuración, y luego Almacenamiento, puede borrar cachés de shaders y prefijos sobrantes de juegos que quitaste. + ¿Encontraste un error? Compartir registros en el menú de sesión reúne los datos de diagnóstico. Publícalos en #bug-reports en Discord. - La primera vez se prepara el escritorio. Puede tardar unos minutos. - De forma predeterminada, al salir de la app la sesión se pausa y continúa donde la dejaste cuando vuelves. + La primera ejecución configura el escritorio. Puede tardar unos minutos. El tacto funciona como un touchpad: arrastra para mover el puntero y toca para hacer clic. - Tu control aparece como un control de Xbox 360. Si no, usa los controles en pantalla. + Comportamiento en segundo plano decide qué pasa al salir de la app: Manual espera a Reanudar de forma predeterminada, Auto pausa y Nunca lo mantiene en ejecución. + Desliza desde el borde derecho para abrir el menú de sesión y elige Teclado de PC para escribir en apps que ignoran el teclado de Android. + El Teclado de PC del menú de sesión tiene tamaño, opacidad y grupos de teclas ajustables. + Tu control aparece como un control Xbox 360. Si no, usa los controles en pantalla. + El menú de sesión tiene un interruptor de micrófono y un botón Suspender ahora para congelar la sesión cuando quieras. + ¿Encontraste un error? Compartir registros en el menú de sesión reúne los datos de diagnóstico. Publícalos en #bug-reports en Discord. Sesión Se muestra mientras hay una sesión de Steam o de escritorio abierta @@ -269,6 +289,10 @@ Touchpad Directo Auto: touchpad en Escritorio, directo en Steam. + Lápiz + Ratón + Táctil + Botón lateral Controles en pantalla Steam + QAM Auto muestra los controles en pantalla cuando no hay ningún control conectado. @@ -606,6 +630,8 @@ Desactivado Predeterminado del controlador Comprimir Steam mientras se ejecuta un juego + Comprimir memoria inactiva del juego + Comprime la memoria inactiva del juego cuando queda poca RAM. Desactívalo si los juegos se congelan unos segundos cada medio minuto aproximadamente. Se aplica la próxima vez que se inicie la sesión. 20 s después de que empiece un juego, el cliente de Steam se comprime en zRAM para dejarle más memoria al juego, y se vuelve a leer cuando el juego se cierra. Desactívalo si la sesión se cierra poco después de iniciar los juegos. Un límite de RAM definido arriba sigue comprimiendo Steam cuando la sesión lo supera. Límite de RAM Se aplica mientras se ejecuta el cliente de Steam, en modo Steam o desde el escritorio. Cuando la sesión usa más de esto, Steam y luego los demás procesos compatibles de la sesión se comprimen en zRAM. Es un límite flexible: no se cierra nada, pero los juegos pueden tener microcortes mientras se recuperan las páginas. @@ -616,7 +642,7 @@ Solo Adreno. Menos microcortes, más consumo de batería y calor. Correcciones de sesión Turnip: renderizado sysmem - Más rápido para el cliente de Steam; en los juegos, el controlador elige entre renderizado por mosaicos o en memoria del sistema en cada pasada. Obligatorio en Adreno 710/720/722. + Se aplica al cliente de Steam y a los juegos. Obligatorio en Adreno 710/720/722. Omitir el asistente xalia de Steam droiddeck-ntsync Un sustituto en espacio de usuario del controlador ntsync de Linux. Mientras está activado, Proton lo usa en lugar de droiddeck-esync y droiddeck-fsync. Funciona con Proton Experimental ARM64, GE-Proton y proton-cachyos. Se aplica en la próxima sesión. @@ -1917,6 +1943,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Borrar Instala primero el runtime La biblioteca de Steam no está disponible La biblioteca anterior de la SD no está disponible @@ -3849,8 +3876,6 @@ Alt+Tab, la tecla Win y el botón Inicio se quedan en la sesión ¿Aparece en gris en Android? Información de la app → ⋮ → Permitir configuración restringida Bloqueado por Android · Información de la app → ⋮ → Permitir configuración restringida - Teclas del sistema de DroidDeck - Mantiene Alt+Tab, la tecla Win y el botón Inicio dentro de una sesión activa de DroidDeck en lugar de Android. Activa Brillo en Configuración → Integración con Steam Puente Mali: desactivado %1$s no puede usar el puente Mali (necesita una GPU Mali sin ruta de controlador del sistema), así que esta opción no tiene efecto aquí. @@ -4012,6 +4037,7 @@ Restablecer posiciones Mostrar etiqueta No se pudo importar esta disposición + Se instala mediante %1$s Nieve escarlata Superficies blancas con acentos rojos. Bandas sonoras diff --git a/app/src/main/res/values-bg/strings.xml b/app/src/main/res/values-bg/strings.xml index a2760406e6..5f44159e56 100644 --- a/app/src/main/res/values-bg/strings.xml +++ b/app/src/main/res/values-bg/strings.xml @@ -9,15 +9,35 @@ DroidDeck не успя да се рестартира автоматично. Затворете приложението напълно и след това го отворете отново. DroidDeck - Първото стартиране изтегля Steam. Това може да отнеме няколко минути. - По подразбиране излизането от приложението поставя Steam на пауза; при връщане продължава от същото място. - Контролерът ви се разпознава като контролер Xbox 360. В противен случай използвайте екранните контроли. + При първото стартиране се изтегля Steam. Това може да отнеме няколко минути. + Контролерът ви се представя на Steam като контролер на Steam Deck. Сменете го със Steam Controller, DualShock 4, DualSense или Xbox 360 в настройките на сесията; прилага се от следващата сесия. + Задръжте Назад на контролера, за да отворите менюто Quick Access на Steam. «Задържане на Назад за преки пътища в Steam» трябва да е включено в настройките на сесията. + Поведение във фонов режим определя какво става, когато излезете от приложението: Системно подготвя Steam за заспиване, Автоматично го паузира, Ръчно чака Продължи, Никога го оставя да работи. + Игрите в Steam ползват Frame Limit на Steam в Quick Access. Екранът превключва към честота на опресняване, на която ограничението се дели точно, ако има такава. + Режим на ниска латентност в менюто на сесията изпраща входа от контролера с 1000 Hz вместо 250 Hz, срещу малко повече процесор и батерия. + Всяка игра има собствен профил с Proton, FEX, компоненти и настройки на средата. + Менюто на сесията има превключвател за микрофон за гласов чат и бутон Приспи сега, който замразява сесията при нужда. + Плъзнете HUD на DroidDeck, за да го преместите, ощипете, за да го преоразмерите, и го избутайте към ръба, за да се закачи като малък раздел с FPS. + На преносими конзоли с два екрана долният екран може да показва изтегляния, известия, снимки на екрана и чата на Steam. Размяна на екраните поставя играта там. + Добавяйте библиотеки на Steam от SD карта, USB устройство или SSD, а DroidDeck държи игрите заедно в Библиотека. + Магазини ви позволява да влезете в Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io и Game Jolt, а после да инсталирате и обновявате техните игри от DroidDeck. + Компоненти като FEX, DXVK и VKD3D-Proton се обновяват сами, а Proton Experimental ARM64 е по подразбиране, или Proton 11.0 ARM64, щом тази версия е инсталирана. + Компресиране на Steam, докато върви игра освобождава RAM на устройства с малко памет. + Плъзнете навътре от десния ръб, за да отворите менюто на сесията: режим на тъчпад, Клавиатура за компютър, Режим на ниска латентност, профил на играта и други. + Играта е бавна? Ограничете кадрите в Quick Access, после опитайте друга версия на Proton или друга предварителна настройка на FEX в компонентите на играта. + Пращене или липсващ звук в играта? Опитайте превключвателя DirectAudio за игри в настройките на Steam, под Звук. + Настройка, после Съхранение, може да изчисти кешовете за шейдъри и остатъчните префикси от игри, които сте премахнали. + Попаднахте на грешка? Споделяне на дневници в менюто на сесията събира диагностични данни. Публикувайте ги в #bug-reports в Discord. - Първото стартиране подготвя работния плот. Това може да отнеме няколко минути. - По подразбиране излизането от приложението поставя сесията на пауза; при връщане тя продължава от същото място. - Докосването действа като тъчпад: плъзгане премества показалеца, докосване щраква. - Контролерът ви се разпознава като контролер Xbox 360. В противен случай използвайте екранните контроли. + При първото стартиране се настройва работният плот. Това може да отнеме няколко минути. + Докосването работи като тъчпад: плъзнете, за да местите показалеца, и докоснете, за да кликнете. + Поведение във фонов режим определя какво става, когато излезете от приложението: Ръчно по подразбиране чака Продължи, Автоматично паузира, Никога го оставя да работи. + Плъзнете навътре от десния ръб, за да отворите менюто на сесията, после изберете Клавиатура за компютър, за да пишете в приложения, които игнорират клавиатурата на Android. + Клавиатурата за компютър в менюто на сесията има регулируеми размер, прозрачност и групи клавиши. + Контролерът ви се представя като контролер Xbox 360. Иначе използвайте контролите на екрана. + Менюто на сесията има превключвател за микрофон и бутон Приспи сега, който замразява сесията при нужда. + Попаднахте на грешка? Споделяне на дневници в менюто на сесията събира диагностични данни. Публикувайте ги в #bug-reports в Discord. Сесия Показва се, докато има отворена сесия на Steam или работния плот @@ -269,6 +289,10 @@ Тъчпад Директно Автоматично: тъчпад на работния плот, директно в Steam. + Писалка + Мишка + Докосване + Страничен бутон Екранни контроли Steam + QAM Автоматично показва контролите, когато няма свързан контролер. @@ -604,6 +628,8 @@ Изкл. По подразбиране за драйвера Компресиране на Steam, докато върви игра + Компресиране на неактивната памет на играта + Компресира неактивната памет на играта при малко RAM. Изключете го, ако игрите замръзват за няколко секунди приблизително на всеки половин минута. Прилага се при следващото стартиране на сесията. 20 s след стартиране на игра клиентът на Steam се компресира в zRAM, за да остави повече памет на играта, и се прочита обратно, когато играта се затвори. Изключете, ако сесията се затваря малко след стартиране на игри. Ограничение на RAM по-горе пак компресира Steam, когато сесията го надхвърли. Ограничение на RAM Прилага се, докато клиентът на Steam работи, в режим Steam или от работния плот. Когато сесията използва повече от това, Steam и след това другите поддържани процеси на сесията се компресират в zRAM. Меко ограничение: нищо не се затваря, но игрите може да засичат, докато страниците се връщат. @@ -614,7 +640,7 @@ Само за Adreno. По-малко засечки, по-голямо използване на батерията и повече топлина. Корекции на сесията Turnip: рендиране sysmem - По-бързо за клиента на Steam; в игрите драйверът избира за всеки проход между рендериране на плочки и в системната памет. Задължително на Adreno 710/720/722. + Прилага се за клиента на Steam и игрите. Изисква се при Adreno 710/720/722. Пропускане на помощника xalia на Steam droiddeck-ntsync Заместител на потребителско ниво за драйвера ntsync на Linux. Докато е включен, Proton го използва вместо droiddeck-esync и droiddeck-fsync. Работи с Proton Experimental ARM64, GE-Proton и proton-cachyos. Прилага се от следващата сесия. @@ -1834,6 +1860,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Изчисти Инсталирай средата първо Библиотеката на Steam не е достъпна Предишната SD библиотека не е достъпна @@ -3837,8 +3864,6 @@ Alt+Tab, клавишът Win и бутонът Начало остават в сесията Неактивно в Android? Информация за приложението → ⋮ → Разрешаване на ограничените настройки Блокирано от Android · Информация за приложението → ⋮ → Разрешаване на ограничените настройки - Системни клавиши на DroidDeck - Задържа Alt+Tab, клавиша Win и бутона Начало в активната сесия на DroidDeck вместо в Android. Включете „Яркост“ в Настройка → Интеграция със Steam Mali мост: изкл. %1$s не може да използва моста Mali (нужен е графичен процесор Mali без маршрут през системен драйвер), затова този превключвател няма ефект тук. @@ -3999,10 +4024,11 @@ Нулиране на позициите Показване на етикета Това разположение не можа да бъде импортирано + Инсталира се чрез %1$s Ален сняг Бели повърхности с червени акценти. - + Саундтраци Музика Опции за възпроизвеждане diff --git a/app/src/main/res/values-cs/strings.xml b/app/src/main/res/values-cs/strings.xml index c0d54caa91..b5ce797262 100644 --- a/app/src/main/res/values-cs/strings.xml +++ b/app/src/main/res/values-cs/strings.xml @@ -10,14 +10,34 @@ DroidDeck První spuštění stáhne Steam. Může to trvat několik minut. - Ve výchozím nastavení se po opuštění aplikace Steam pozastaví; po návratu pokračuje, kde skončil. - Váš ovladač se zobrazí jako ovladač Xbox 360. Jinak použijte ovládání na obrazovce. + Váš ovladač se Steamu hlásí jako ovladač Steam Deck. V nastavení relace ho přepněte na Steam Controller, DualShock 4, DualSense nebo Xbox 360; použije se od příští relace. + Podržením Zpět na ovladači otevřete nabídku Quick Access ve Steamu. V nastavení relace musí být zapnuté Podržení Zpět pro zkratky Steam. + Chování na pozadí určuje, co se stane po opuštění aplikace: Nativní připraví Steam na uspání, Automaticky ho pozastaví, Manuální čeká na Obnovit, Nikdy ho nechá běžet. + Hry ze Steamu používají Frame Limit ze Steamu v Quick Access. Displej se přepne na obnovovací frekvenci, kterou limit dělí beze zbytku, pokud nějaká existuje. + Režim nízkého zpoždění v nabídce relace posílá vstup z ovladače rychlostí 1000 Hz místo 250 Hz za cenu o něco vyššího zatížení procesoru a baterie. + Každá hra má vlastní profil s nastavením Proton, FEX, komponent a prostředí. + Nabídka relace obsahuje přepínač mikrofonu pro hlasový chat a tlačítko Pozastavit teď, které relaci na požádání zmrazí. + HUD DroidDeck přesunete přetažením, velikost změníte roztažením prsty a když ho odsunete k okraji, připne se jako malá karta s FPS. + U kapesních konzolí se dvěma displeji může spodní displej zobrazovat stahování, oznámení, snímky obrazovky a chat Steamu. Prohodit obrazovky tam místo toho přesune hru. + Přidejte knihovny Steamu z SD karty, USB disku nebo SSD a DroidDeck udrží hry pohromadě v Knihovně. + Obchody vám umožní přihlásit se do Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io a Game Jolt a pak instalovat a aktualizovat jejich hry přímo z DroidDeck. + Komponenty jako FEX, DXVK a VKD3D-Proton se aktualizují samy a výchozí je Proton Experimental ARM64, případně Proton 11.0 ARM64, jakmile je tato verze nainstalovaná. + Komprimovat Steam během hry uvolní RAM na zařízeních s nedostatkem paměti. + Přejetím od pravého okraje otevřete nabídku relace: režim touchpadu, Klávesnice PC, Režim nízkého zpoždění, profil hry a další. + Hra běží pomalu? Omezte snímkovou frekvenci v Quick Access a zkuste jinou verzi Proton nebo jinou předvolbu FEX v komponentách hry. + Praskání nebo chybějící zvuk ve hře? Zkuste přepínač DirectAudio pro hry v nastavení Steamu v části Zvuk. + Příprava a potom Úložiště umí vymazat mezipaměti shaderů a zbylé prefixy po odstraněných hrách. + Narazili jste na chybu? Sdílet protokoly v nabídce relace sbalí diagnostiku. Pošlete ji do #bug-reports na Discordu. - První spuštění připraví Plochu. Může to trvat několik minut. - Ve výchozím nastavení se po opuštění aplikace relace pozastaví; po návratu pokračuje, kde skončila. - Dotyk funguje jako touchpad: tažením posouváte kurzor, dotykem klikáte. - Váš ovladač se zobrazí jako ovladač Xbox 360. Jinak použijte ovládání na obrazovce. + První spuštění připraví plochu. Může to trvat několik minut. + Dotyk funguje jako touchpad: tažením pohybujete ukazatelem, klepnutím klikáte. + Chování na pozadí určuje, co se stane po opuštění aplikace: Manuální ve výchozím stavu čeká na Obnovit, Automaticky pozastaví, Nikdy nechá běžet. + Přejetím od pravého okraje otevřete nabídku relace a poté zvolte Klávesnice PC, abyste mohli psát v aplikacích, které ignorují klávesnici Androidu. + Klávesnice PC v nabídce relace má nastavitelnou velikost, průhlednost a skupiny kláves. + Váš ovladač se hlásí jako ovladač Xbox 360. Jinak použijte ovládací prvky na obrazovce. + Nabídka relace obsahuje přepínač mikrofonu a tlačítko Pozastavit teď, které relaci na požádání zmrazí. + Narazili jste na chybu? Sdílet protokoly v nabídce relace sbalí diagnostiku. Pošlete ji do #bug-reports na Discordu. Relace Zobrazuje se, když je otevřená relace Steamu nebo Plochy @@ -269,6 +289,10 @@ Touchpad Přímé Automaticky: touchpad na Ploše, přímo ve Steamu. + Pero + Myš + Dotyk + Boční tlačítko Ovládání na obrazovce Steam + QAM Automaticky zobrazí ovládání, pokud není připojen žádný ovladač. @@ -608,6 +632,8 @@ Vypnuto Výchozí ovladače Komprimovat Steam během hry + Komprimovat neaktivní paměť hry + Při nedostatku RAM stránkuje neaktivní paměť hry. Vypněte to, pokud hry zhruba každou půlminutu na několik sekund zamrznou. Projeví se při příštím spuštění relace. 20 s po spuštění hry se klient Steam zkomprimuje do zRAM, aby hře zbylo více paměti, a po zavření hry se načte zpět. Vypněte, pokud se relace krátce po spuštění her zavírá. Limit RAM výše stále komprimuje Steam, když ho relace překročí. Limit RAM Platí, když běží klient Steam, v režimu Steam nebo z Plochy. Když relace použije víc, zkomprimuje se do zRAM Steam a poté další podporované procesy relace. Měkký limit: nic se nezavře, ale hry mohou trhat, než se stránky načtou zpět. @@ -618,7 +644,7 @@ Jen Adreno. Méně zadrhávání, více spotřeby baterie a tepla. Opravy relace Turnip: vykreslování sysmem - Rychlejší pro klienta Steam; ve hrách ovladač pro každý průchod volí dlaždicové vykreslování, nebo vykreslování v systémové paměti. Vyžadováno na Adreno 710/720/722. + Platí pro klienta Steam i hry. Vyžadováno na Adreno 710/720/722. Vynechat Steamova pomocníka xalia droiddeck-ntsync Uživatelská náhrada linuxového ovladače ntsync. Když je zapnuto, Proton ho používá místo droiddeck-esync a droiddeck-fsync. Funguje s Proton Experimental ARM64, GE-Proton a proton-cachyos. Použije se od příští relace. @@ -1872,6 +1898,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Vymazat Nejprve nainstalujte runtime Knihovna Steamu není dostupná Předchozí knihovna na SD kartě není dostupná @@ -3915,8 +3942,6 @@ Alt+Tab, klávesa Win a tlačítko Domů zůstanou v relaci V Androidu zašedlé? Informace o aplikaci → ⋮ → Povolit omezená nastavení Blokováno Androidem · Informace o aplikaci → ⋮ → Povolit omezená nastavení - Systémové klávesy DroidDeck - Ponechá Alt+Tab, klávesu Win a tlačítko Domů v aktivní relaci DroidDeck místo Androidu. Zapněte Jas v Příprava → Integrace se Steamem Most Mali: vypnuto %1$s nemůže použít most Mali (potřebuje GPU Mali bez trasy přes systémový ovladač), takže tento přepínač tady nemá žádný účinek. @@ -4079,10 +4104,11 @@ Obnovit pozice Zobrazit popisek Toto rozložení nelze importovat + Instaluje se přes %1$s Šarlatový sníh Bílé povrchy s červenými akcenty. - + Soundtracky Hudba Možnosti přehrávání diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 443b2a96cb..28d75b49cb 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -9,15 +9,35 @@ DroidDeck kunne ikke genstarte automatisk. Luk appen helt, og åbn den så igen. DroidDeck - Den første start downloader Steam. Det kan tage nogle minutter. - Som standard sætter Steam på pause, når du forlader appen, og fortsætter, hvor du slap, når du kommer tilbage. - Din controller vises som en Xbox 360-controller. Brug ellers kontrollerne på skærmen. + Første kørsel downloader Steam. Det kan tage et par minutter. + Din controller vises i Steam som en Steam Deck-controller. Skift den til Steam Controller, DualShock 4, DualSense eller Xbox 360 i sessionsindstillingerne. Det gælder fra næste session. + Hold Tilbage nede på din controller for at åbne Steams Hurtig adgang-menu. Hold Tilbage for Steam-genveje skal være slået til i sessionsindstillingerne. + Baggrundsopførsel bestemmer, hvad der sker, når du forlader appen: Native gør Steam klar til dvale, Auto sætter det på pause, Manuel venter på Genoptag, Aldrig lader det køre. + Steam-spil bruger Steams Frame Limit i Hurtig adgang. Skærmen skifter til en opdateringsfrekvens, som grænsen går op i, hvis der findes en. + Lav forsinkelse i sessionsmenuen sender controllerinput med 1000 Hz i stedet for 250 Hz, til gengæld for lidt mere CPU og batteri. + Hvert spil har sin egen profil med Proton, FEX, komponenter og miljøindstillinger. + Sessionsmenuen har en mikrofonknap til stemmechat og en Sæt på pause nu-knap, der fryser sessionen efter behov. + Træk DroidDeck HUD for at flytte det, knib for at ændre størrelsen, og skub det ud mod en kant for at fæstne det som en lille FPS-fane. + På håndholdte med to skærme kan den nederste skærm vise downloads, notifikationer, skærmbilleder og Steam-chat. Byt skærme lægger i stedet spillet dernede. + Tilføj Steam-biblioteker fra et SD-kort, et USB-drev eller en SSD, så samler DroidDeck spillene i dit Bibliotek. + Butikker lader dig logge ind på Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io og Game Jolt og derefter installere og opdatere deres spil fra DroidDeck. + Komponenter som FEX, DXVK og VKD3D-Proton opdaterer sig selv, og Proton Experimental ARM64 er standard, eller Proton 11.0 ARM64, når den version er installeret. + Komprimer Steam, mens et spil kører frigør RAM på enheder med lidt hukommelse. + Stryg ind fra højre kant for at åbne sessionsmenuen: touchpad-tilstand, PC-tastatur, Lav forsinkelse, spilprofil og mere. + Kører spillet langsomt? Begræns billedfrekvensen i Hurtig adgang, og prøv så en anden Proton-version eller FEX-forudindstilling i spillets komponenter. + Knitrende eller manglende lyd i spillet? Prøv kontakten DirectAudio til spil i Steam-indstillingerne under Lyd. + Opsætning og så Lager kan rydde shader-caches og overskydende præfikser fra spil, du har fjernet. + Har du ramt en fejl? Del logs i sessionsmenuen samler diagnostik. Send dem i #bug-reports på Discord. - Den første start sætter skrivebordet op. Det kan tage nogle minutter. - Som standard sætter sessionen på pause, når du forlader appen, og fortsætter, hvor du slap, når du kommer tilbage. - Berøring fungerer som et touchpad: Træk for at flytte markøren, tryk for at klikke. - Din controller vises som en Xbox 360-controller. Brug ellers kontrollerne på skærmen. + Første kørsel sætter skrivebordet op. Det kan tage et par minutter. + Touch fungerer som et touchpad: træk for at flytte markøren, tryk for at klikke. + Baggrundsopførsel bestemmer, hvad der sker, når du forlader appen: Manuel venter som standard på Genoptag, Auto sætter på pause, Aldrig lader det køre. + Stryg ind fra højre kant for at åbne sessionsmenuen, og vælg så PC-tastatur for at skrive i apps, der ignorerer Android-tastaturet. + PC-tastaturet i sessionsmenuen har justerbar størrelse, gennemsigtighed og tastgrupper. + Din controller vises som en Xbox 360-controller. Ellers kan du bruge betjeningen på skærmen. + Sessionsmenuen har en mikrofonknap og en Sæt på pause nu-knap, der fryser sessionen efter behov. + Har du ramt en fejl? Del logs i sessionsmenuen samler diagnostik. Send dem i #bug-reports på Discord. Session Vises, når en Steam- eller skrivebordssession er åben @@ -269,6 +289,10 @@ Touchpad Direkte Auto: touchpad på Skrivebord, direkte i Steam. + Pen + Mus + Berøring + Sideknap Kontroller på skærmen Steam + QAM Auto viser kontrollerne, når ingen controller er tilsluttet. @@ -604,6 +628,8 @@ Fra Driverstandard Komprimer Steam, mens et spil kører + Komprimer spillets inaktive hukommelse + Pager spillets inaktive hukommelse ud, når RAM er lav. Slå det fra, hvis spil fryser i et par sekunder cirka hvert halve minut. Træder i kraft, næste gang sessionen starter. 20 s efter et spil starter, komprimeres Steam-klienten i zRAM for at give spillet mere hukommelse, og læses tilbage, når spillet lukkes. Slå fra, hvis sessionen lukker kort efter, at spil starter. En RAM-grænse ovenfor komprimerer stadig Steam, når sessionen overskrider den. RAM-grænse Gælder, mens Steam-klienten kører, i Steam-tilstand eller fra skrivebordet. Når sessionen bruger mere end dette, komprimeres Steam og derefter sessionens andre understøttede processer i zRAM. En blød grænse: intet lukkes, men spil kan hakke, mens sider hentes tilbage. @@ -614,7 +640,7 @@ Kun Adreno. Færre hak, mere batteribrug og varme. Sessionsrettelser Turnip: sysmem-rendering - Hurtigere til Steam-klienten; i spil vælger driveren flise- eller systemhukommelses-rendering for hvert pass. Påkrævet på Adreno 710/720/722. + Gælder Steam-klienten og spil. Påkrævet på Adreno 710/720/722. Spring Steams xalia-hjælper over droiddeck-ntsync En stand-in til ntsync-driveren i Linux-kernen, i brugerrum. Mens den er til, bruger Proton den i stedet for droiddeck-esync og droiddeck-fsync. Fungerer med Proton Experimental ARM64, GE-Proton og proton-cachyos. Gælder fra næste session. @@ -1834,6 +1860,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Ryd Installer runtime først Steam-biblioteket er ikke tilgængeligt Det tidligere SD-bibliotek er ikke tilgængeligt @@ -3837,8 +3864,6 @@ Alt+Tab, Win-tasten og Hjem-knappen bliver i sessionen Nedtonet i Android? Appinfo → ⋮ → Tillad begrænsede indstillinger Blokeret af Android · Appinfo → ⋮ → Tillad begrænsede indstillinger - DroidDeck-systemtaster - Holder Alt+Tab, Win-tasten og Hjem-knappen i en aktiv DroidDeck-session i stedet for Android. Slå Lysstyrke til under Opsætning → Steam-integration Mali-bro: fra %1$s kan ikke bruge Mali-broen (den kræver en Mali-GPU uden en rute gennem systemdriveren), så denne kontakt har ingen virkning her. @@ -3999,10 +4024,11 @@ Nulstil placeringer Vis etiket Dette layout kunne ikke importeres + Installeres via %1$s Skarlagensne Hvide overflader med røde accenter. - + Soundtracks Musik Afspilningsindstillinger diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 41e8e685eb..1f21e47271 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -9,15 +9,35 @@ DroidDeck konnte nicht automatisch neu starten. Schließe die App vollständig und öffne sie dann erneut. DroidDeck - Beim ersten Start wird Steam heruntergeladen. Das kann ein paar Minuten dauern. - Standardmäßig pausiert Steam, wenn du die App verlässt, und macht bei deiner Rückkehr dort weiter, wo es aufgehört hat. - Dein Controller erscheint als Xbox-360-Pad. Ansonsten nutze die Bildschirmsteuerung. + Beim ersten Start wird Steam heruntergeladen. Das kann einige Minuten dauern. + Dein Controller erscheint in Steam als Steam-Deck-Controller. Stelle ihn in den Sitzungseinstellungen auf Steam Controller, DualShock 4, DualSense oder Xbox 360 um; das gilt ab der nächsten Sitzung. + Halte Zurück auf deinem Controller gedrückt, um das Schnellzugriffsmenü von Steam zu öffnen. Zurück halten für Steam-Kürzel muss in den Sitzungseinstellungen aktiviert sein. + Verhalten im Hintergrund legt fest, was beim Verlassen der App passiert: Nativ bereitet Steam auf den Ruhezustand vor, Auto pausiert es, Manuell wartet auf Fortsetzen, Nie lässt es weiterlaufen. + Steam-Spiele nutzen das Frame Limit von Steam im Schnellzugriff. Das Display wechselt auf eine Bildwiederholrate, durch die sich das Limit teilen lässt, sofern es eine gibt. + Modus mit geringer Latenz im Sitzungsmenü sendet Controller-Eingaben mit 1000 Hz statt 250 Hz, auf Kosten von etwas mehr CPU-Last und Akkuverbrauch. + Jedes Spiel hat ein eigenes Profil mit Proton, FEX, Komponenten und Umgebungseinstellungen. + Das Sitzungsmenü hat einen Mikrofonschalter für den Sprachchat und eine Schaltfläche Jetzt anhalten, mit der du die Sitzung nach Bedarf einfrierst. + Ziehe das DroidDeck-HUD, um es zu verschieben, zoome mit zwei Fingern, um die Größe zu ändern, und schiebe es an einen Rand, um es als kleinen FPS-Tab anzudocken. + Bei Handhelds mit zwei Bildschirmen kann der untere Bildschirm Downloads, Benachrichtigungen, Screenshots und den Steam-Chat anzeigen. Bildschirme tauschen legt stattdessen das Spiel dorthin. + Füge Steam-Bibliotheken von einer SD-Karte, einem USB-Laufwerk oder einer SSD hinzu, und DroidDeck hält die Spiele in deiner Bibliothek zusammen. + Mit Stores meldest du dich bei Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io und Game Jolt an und installierst und aktualisierst deren Spiele direkt in DroidDeck. + Komponenten wie FEX, DXVK und VKD3D-Proton aktualisieren sich selbst, und Proton Experimental ARM64 ist der Standard, oder Proton 11.0 ARM64, sobald diese Version installiert ist. + Steam komprimieren, während ein Spiel läuft gibt auf Geräten mit knappem Arbeitsspeicher RAM frei. + Wische vom rechten Rand nach innen, um das Sitzungsmenü zu öffnen: Touchpad-Modus, PC-Tastatur, Modus mit geringer Latenz, Spielprofil und mehr. + Das Spiel läuft langsam? Begrenze die Bildrate im Schnellzugriff und probiere dann eine andere Proton-Version oder ein anderes FEX-Preset in den Komponenten des Spiels. + Knacken oder fehlender Spielton? Probiere den Schalter DirectAudio für Spiele in den Steam-Einstellungen unter Audio. + Einrichtung und dann Speicher kann Shader-Caches und übrig gebliebene Präfixe von entfernten Spielen löschen. + Auf einen Fehler gestoßen? Logs teilen im Sitzungsmenü bündelt Diagnosedaten. Poste sie in #bug-reports auf Discord. - Beim ersten Start wird der Desktop eingerichtet. Das kann ein paar Minuten dauern. - Standardmäßig wird die Sitzung pausiert, wenn du die App verlässt, und macht bei deiner Rückkehr dort weiter, wo sie aufgehört hat. + Beim ersten Start wird der Desktop eingerichtet. Das kann einige Minuten dauern. Touch funktioniert wie ein Touchpad: Ziehen bewegt den Zeiger, Tippen klickt. - Dein Controller erscheint als Xbox-360-Pad. Ansonsten nutze die Bildschirmsteuerung. + Verhalten im Hintergrund legt fest, was beim Verlassen der App passiert: Manuell wartet standardmäßig auf Fortsetzen, Auto pausiert, Nie lässt es weiterlaufen. + Wische vom rechten Rand nach innen, um das Sitzungsmenü zu öffnen, und wähle dann PC-Tastatur, um in Apps zu tippen, die die Android-Tastatur ignorieren. + Die PC-Tastatur im Sitzungsmenü hat einstellbare Größe, Deckkraft und Tastengruppen. + Dein Controller erscheint als Xbox-360-Controller. Andernfalls nutze die Bedienelemente auf dem Bildschirm. + Das Sitzungsmenü hat einen Mikrofonschalter und eine Schaltfläche Jetzt anhalten, mit der du die Sitzung nach Bedarf einfrierst. + Auf einen Fehler gestoßen? Logs teilen im Sitzungsmenü bündelt Diagnosedaten. Poste sie in #bug-reports auf Discord. Sitzung Wird angezeigt, solange eine Steam- oder Desktop-Sitzung geöffnet ist @@ -269,6 +289,10 @@ Touchpad Direkt Auto: Touchpad auf dem Desktop, direkt in Steam. + Stift + Maus + Touch + Seitentaste Bildschirmsteuerung Steam + QAM Auto zeigt die Steuerung an, wenn kein Controller verbunden ist. @@ -604,6 +628,8 @@ Aus Treiberstandard Steam komprimieren, während ein Spiel läuft + Inaktiven Spielspeicher komprimieren + Lagert inaktiven Spielspeicher bei knappem RAM aus. Schalte dies aus, wenn Spiele etwa jede halbe Minute für einige Sekunden einfrieren. Gilt ab dem nächsten Start der Sitzung. 20 s nach dem Spielstart wird der Steam-Client in zRAM komprimiert, um dem Spiel mehr Speicher zu lassen, und beim Beenden des Spiels zurückgelesen. Schalte dies aus, wenn sich die Sitzung kurz nach dem Spielstart schließt. Ein RAM-Limit oben komprimiert Steam weiterhin, wenn die Sitzung es überschreitet. RAM-Limit Gilt, solange der Steam-Client läuft, im Steam-Modus oder vom Desktop aus. Verbraucht die Sitzung mehr als diesen Wert, werden Steam und danach die übrigen unterstützten Prozesse der Sitzung in zRAM komprimiert. Ein weiches Limit: Nichts wird geschlossen, aber Spiele können ruckeln, während Seiten zurückgeladen werden. @@ -614,7 +640,7 @@ Nur Adreno. Weniger Ruckler, mehr Akkuverbrauch und Wärme. Sitzungskorrekturen Turnip: Sysmem-Rendering - Schneller für den Steam-Client; in Spielen wählt der Treiber pro Durchgang zwischen Kachel- und Systemspeicher-Rendering. Erforderlich bei Adreno 710/720/722. + Gilt für den Steam-Client und Spiele. Erforderlich bei Adreno 710/720/722. Steams xalia-Helfer überspringen droiddeck-ntsync Ein Userspace-Ersatz für den Linux-Treiber ntsync. Solange er aktiv ist, nutzt Proton ihn statt droiddeck-esync und droiddeck-fsync. Funktioniert mit Proton Experimental ARM64, GE-Proton und proton-cachyos. Gilt ab der nächsten Sitzung. @@ -1826,6 +1852,7 @@ %1$s ✓ Strg+C Strg+D + Leeren Installiere zuerst die Laufzeit Steam-Bibliothek ist nicht verfügbar Vorherige SD-Bibliothek ist nicht verfügbar @@ -3837,8 +3864,6 @@ Alt+Tab, Win-Taste und Home-Taste bleiben in der Sitzung In Android ausgegraut? App-Info → ⋮ → Eingeschränkte Einstellungen zulassen Von Android blockiert · App-Info → ⋮ → Eingeschränkte Einstellungen zulassen - DroidDeck-Systemtasten - Hält Alt+Tab, die Win-Taste und die Home-Taste in einer aktiven DroidDeck-Sitzung statt bei Android. Aktiviere Helligkeit unter Einrichtung → Steam-Integration Mali-Brücke: aus %1$s kann die Mali-Brücke nicht nutzen (sie benötigt eine Mali-GPU ohne Systemtreiber-Route), daher hat dieser Schalter hier keine Wirkung. @@ -3999,10 +4024,11 @@ Positionen zurücksetzen Beschriftung anzeigen Dieses Layout konnte nicht importiert werden + Wird über %1$s installiert Scharlachroter Schnee Weiße Oberflächen mit roten Akzenten. - + Soundtracks Musik Wiedergabeoptionen diff --git a/app/src/main/res/values-el/strings.xml b/app/src/main/res/values-el/strings.xml index 70c09dfcde..ee0fec4765 100644 --- a/app/src/main/res/values-el/strings.xml +++ b/app/src/main/res/values-el/strings.xml @@ -9,15 +9,35 @@ Το DroidDeck δεν μπόρεσε να κάνει αυτόματη επανεκκίνηση. Κλείστε εντελώς την εφαρμογή και ανοίξτε την ξανά. DroidDeck - Η πρώτη εκτέλεση κάνει λήψη του Steam. Αυτό μπορεί να διαρκέσει μερικά λεπτά. - Από προεπιλογή, η έξοδος από την εφαρμογή θέτει το Steam σε παύση· συνεχίζει από εκεί που είχε μείνει όταν επιστρέψετε. - Το χειριστήριό σας εμφανίζεται ως χειριστήριο Xbox 360. Διαφορετικά, χρησιμοποιήστε τα χειριστήρια στην οθόνη. + Η πρώτη εκτέλεση κατεβάζει το Steam. Μπορεί να διαρκέσει μερικά λεπτά. + Το χειριστήριό σας εμφανίζεται στο Steam ως χειριστήριο Steam Deck. Αλλάξτε το σε Steam Controller, DualShock 4, DualSense ή Xbox 360 στις ρυθμίσεις συνεδρίας· εφαρμόζεται στην επόμενη συνεδρία. + Κρατήστε πατημένο το Πίσω στο χειριστήριό σας για να ανοίξετε το μενού Quick Access του Steam. Η επιλογή «Παρατεταμένο Πίσω για συντομεύσεις Steam» πρέπει να είναι ενεργή στις ρυθμίσεις συνεδρίας. + Η Συμπεριφορά παρασκηνίου καθορίζει τι γίνεται όταν φεύγετε από την εφαρμογή: το Εγγενής ετοιμάζει το Steam για αναστολή λειτουργίας, το Αυτόματο το θέτει σε παύση, το Μη αυτόματο περιμένει τη Συνέχιση, το Ποτέ το αφήνει να τρέχει. + Τα παιχνίδια Steam χρησιμοποιούν το Frame Limit του Steam στο Quick Access. Η οθόνη αλλάζει σε ρυθμό ανανέωσης που διαιρείται ακριβώς με το όριο, όταν υπάρχει τέτοιος. + Η Λειτουργία χαμηλής καθυστέρησης στο μενού συνεδρίας στέλνει την είσοδο του χειριστηρίου στα 1000 Hz αντί για 250 Hz, με λίγο μεγαλύτερη χρήση CPU και μπαταρίας. + Κάθε παιχνίδι έχει το δικό του προφίλ με Proton, FEX, στοιχεία και ρυθμίσεις περιβάλλοντος. + Το μενού συνεδρίας έχει διακόπτη μικροφώνου για φωνητική συνομιλία και κουμπί Αναστολή τώρα για να παγώνετε τη συνεδρία όποτε θέλετε. + Σύρετε το HUD του DroidDeck για να το μετακινήσετε, τσιμπήστε για να αλλάξετε μέγεθος και σπρώξτε το προς μια άκρη για να καρφιτσωθεί ως μικρή καρτέλα FPS. + Σε φορητές κονσόλες με δύο οθόνες, η κάτω οθόνη μπορεί να δείχνει λήψεις, ειδοποιήσεις, στιγμιότυπα οθόνης και τη συνομιλία του Steam. Η Εναλλαγή οθονών βάζει εκεί το παιχνίδι. + Προσθέστε βιβλιοθήκες Steam από κάρτα SD, μονάδα USB ή SSD, και το DroidDeck κρατά τα παιχνίδια μαζί στη Βιβλιοθήκη σας. + Τα Καταστήματα σάς επιτρέπουν να συνδεθείτε σε Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io και Game Jolt και μετά να εγκαθιστάτε και να ενημερώνετε τα παιχνίδια τους από το DroidDeck. + Στοιχεία όπως τα FEX, DXVK και VKD3D-Proton ενημερώνονται μόνα τους, και το Proton Experimental ARM64 είναι το προεπιλεγμένο, ή το Proton 11.0 ARM64 μόλις εγκατασταθεί αυτή η έκδοση. + Η επιλογή Συμπίεση του Steam όσο τρέχει παιχνίδι ελευθερώνει RAM σε συσκευές με λίγη μνήμη. + Σύρετε προς τα μέσα από τη δεξιά άκρη για να ανοίξετε το μενού συνεδρίας: λειτουργία πινακίδας αφής, Πληκτρολόγιο PC, Λειτουργία χαμηλής καθυστέρησης, προφίλ παιχνιδιού και άλλα. + Το παιχνίδι τρέχει αργά; Περιορίστε τον ρυθμό καρέ στο Quick Access και δοκιμάστε άλλη έκδοση Proton ή άλλη προεπιλογή FEX στα στοιχεία του παιχνιδιού. + Κροταλίσματα ή απουσία ήχου στο παιχνίδι; Δοκιμάστε τον διακόπτη DirectAudio για παιχνίδια στις ρυθμίσεις του Steam, στην ενότητα Ήχος. + Η Ρύθμιση και μετά η Αποθήκευση μπορεί να καθαρίσει τις κρυφές μνήμες shader και τα υπολειπόμενα prefix από παιχνίδια που αφαιρέσατε. + Αντιμετωπίσατε σφάλμα; Η Κοινή χρήση αρχείων καταγραφής στο μενού συνεδρίας συγκεντρώνει διαγνωστικά. Αναρτήστε τα στο #bug-reports στο Discord. - Η πρώτη εκτέλεση ρυθμίζει την επιφάνεια εργασίας. Αυτό μπορεί να διαρκέσει μερικά λεπτά. - Από προεπιλογή, η έξοδος από την εφαρμογή θέτει τη συνεδρία σε παύση· συνεχίζει από εκεί που είχε μείνει όταν επιστρέψετε. - Το άγγιγμα λειτουργεί ως πινακίδα αφής: σύρετε για να μετακινήσετε τον δείκτη, πατήστε για κλικ. - Το χειριστήριό σας εμφανίζεται ως χειριστήριο Xbox 360. Διαφορετικά, χρησιμοποιήστε τα χειριστήρια στην οθόνη. + Η πρώτη εκτέλεση ρυθμίζει την επιφάνεια εργασίας. Μπορεί να διαρκέσει μερικά λεπτά. + Η αφή λειτουργεί ως πινακίδα αφής: σύρετε για να μετακινήσετε τον δείκτη, πατήστε για κλικ. + Η Συμπεριφορά παρασκηνίου καθορίζει τι γίνεται όταν φεύγετε από την εφαρμογή: το Μη αυτόματο περιμένει από προεπιλογή τη Συνέχιση, το Αυτόματο θέτει σε παύση, το Ποτέ το αφήνει να τρέχει. + Σύρετε προς τα μέσα από τη δεξιά άκρη για να ανοίξετε το μενού συνεδρίας και επιλέξτε Πληκτρολόγιο PC για να πληκτρολογείτε σε εφαρμογές που αγνοούν το πληκτρολόγιο του Android. + Το Πληκτρολόγιο PC στο μενού συνεδρίας έχει ρυθμιζόμενο μέγεθος, αδιαφάνεια και ομάδες πλήκτρων. + Το χειριστήριό σας εμφανίζεται ως χειριστήριο Xbox 360. Διαφορετικά, χρησιμοποιήστε τα χειριστήρια οθόνης. + Το μενού συνεδρίας έχει διακόπτη μικροφώνου και κουμπί Αναστολή τώρα για να παγώνετε τη συνεδρία όποτε θέλετε. + Αντιμετωπίσατε σφάλμα; Η Κοινή χρήση αρχείων καταγραφής στο μενού συνεδρίας συγκεντρώνει διαγνωστικά. Αναρτήστε τα στο #bug-reports στο Discord. Συνεδρία Εμφανίζεται όσο μια συνεδρία Steam ή επιφάνειας εργασίας είναι ανοιχτή @@ -269,6 +289,10 @@ Πινακίδα αφής Απευθείας Αυτόματο: πινακίδα αφής στην Επιφάνεια εργασίας, απευθείας στο Steam. + Γραφίδα + Ποντίκι + Αφή + Πλαϊνό κουμπί Χειριστήρια στην οθόνη Steam + QAM Το Αυτόματο εμφανίζει τα χειριστήρια όταν δεν είναι συνδεδεμένο χειριστήριο. @@ -604,6 +628,8 @@ Ανενεργό Προεπιλογή προγράμματος οδήγησης Συμπίεση του Steam όσο τρέχει παιχνίδι + Συμπίεση ανενεργής μνήμης παιχνιδιού + Σελιδοποιεί την ανενεργή μνήμη του παιχνιδιού όταν η RAM είναι χαμηλή. Απενεργοποιήστε το αν τα παιχνίδια παγώνουν για λίγα δευτερόλεπτα περίπου κάθε μισό λεπτό. Ισχύει από την επόμενη έναρξη της συνεδρίας. 20 s μετά την εκκίνηση ενός παιχνιδιού, ο πελάτης Steam συμπιέζεται στη zRAM για να μείνει περισσότερη μνήμη στο παιχνίδι, και διαβάζεται πίσω όταν το παιχνίδι κλείσει. Απενεργοποιήστε το αν η συνεδρία κλείνει λίγο μετά την εκκίνηση παιχνιδιών. Ένα όριο RAM παραπάνω εξακολουθεί να συμπιέζει το Steam όταν η συνεδρία το ξεπεράσει. Όριο RAM Ισχύει όσο τρέχει ο πελάτης Steam, σε λειτουργία Steam ή από την επιφάνεια εργασίας. Όταν η συνεδρία χρησιμοποιεί περισσότερη, το Steam και έπειτα οι άλλες υποστηριζόμενες διεργασίες της συνεδρίας συμπιέζονται στη zRAM. Ήπιο όριο: τίποτα δεν κλείνει, αλλά τα παιχνίδια μπορεί να κολλάνε όσο επιστρέφουν οι σελίδες. @@ -614,7 +640,7 @@ Μόνο Adreno. Λιγότερα κολλήματα, μεγαλύτερη χρήση μπαταρίας και θερμότητα. Διορθώσεις συνεδρίας Turnip: απόδοση sysmem - Ταχύτερο για το πρόγραμμα-πελάτη Steam· στα παιχνίδια ο οδηγός επιλέγει σε κάθε πέρασμα απόδοση με πλακίδια ή στη μνήμη συστήματος. Απαιτείται σε Adreno 710/720/722. + Ισχύει για το πρόγραμμα-πελάτη Steam και τα παιχνίδια. Απαιτείται σε Adreno 710/720/722. Παράβλεψη του βοηθού xalia του Steam droiddeck-ntsync Ένα υποκατάστατο σε επίπεδο χρήστη για το πρόγραμμα οδήγησης ntsync του Linux. Όσο είναι ενεργό, το Proton το χρησιμοποιεί αντί για το droiddeck-esync και το droiddeck-fsync. Λειτουργεί με Proton Experimental ARM64, GE-Proton και proton-cachyos. Εφαρμόζεται στην επόμενη συνεδρία. @@ -1834,6 +1860,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Καθαρισμός Εγκαταστήστε πρώτα το runtime Η βιβλιοθήκη Steam δεν είναι διαθέσιμη Η προηγούμενη βιβλιοθήκη SD δεν είναι διαθέσιμη @@ -3837,8 +3864,6 @@ Τα Alt+Tab, Win και Αρχική μένουν στη συνεδρία Γκρίζο στο Android; Πληροφορίες εφαρμογής → ⋮ → Να επιτρέπονται οι περιορισμένες ρυθμίσεις Αποκλείεται από το Android · Πληροφορίες εφαρμογής → ⋮ → Να επιτρέπονται οι περιορισμένες ρυθμίσεις - Πλήκτρα συστήματος DroidDeck - Διατηρεί τα Alt+Tab, το πλήκτρο Win και το κουμπί Αρχικής στην ενεργή συνεδρία DroidDeck αντί για το Android. Ενεργοποιήστε τη Φωτεινότητα στη Ρύθμιση → Ενσωμάτωση Steam Γέφυρα Mali: ανενεργή Το %1$s δεν μπορεί να χρησιμοποιήσει τη γέφυρα Mali (χρειάζεται GPU Mali χωρίς διαδρομή οδηγού συστήματος), επομένως αυτός ο διακόπτης δεν έχει καμία επίδραση εδώ. @@ -3999,10 +4024,11 @@ Επαναφορά θέσεων Εμφάνιση ετικέτας Δεν ήταν δυνατή η εισαγωγή αυτής της διάταξης + Εγκαθίσταται μέσω %1$s Κατακόκκινο χιόνι Λευκές επιφάνειες με κόκκινες λεπτομέρειες. - + Soundtrack Μουσική Επιλογές αναπαραγωγής diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index dedf2b43ff..ae7063e602 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -9,15 +9,35 @@ DroidDeck no pudo reiniciarse automáticamente. Cierra la app por completo y vuelve a abrirla. DroidDeck - La primera vez se descarga Steam. Puede tardar unos minutos. - De forma predeterminada, al salir de la app Steam se pausa y continúa donde lo dejaste cuando vuelves. - Tu mando aparece como un mando Xbox 360. Si no, usa los controles en pantalla. + La primera ejecución descarga Steam. Puede tardar unos minutos. + Tu control aparece en Steam como un control de Steam Deck. Cámbialo a Steam Controller, DualShock 4, DualSense o Xbox 360 en los ajustes de la sesión; se aplica en la próxima sesión. + Mantén Atrás en tu control para abrir el menú Quick Access de Steam. «Mantener Atrás para atajos de Steam» debe estar activado en los ajustes de la sesión. + Comportamiento en segundo plano decide qué pasa al salir de la app: Nativo prepara Steam para suspenderse, Auto lo pausa, Manual espera a Reanudar y Nunca lo mantiene en ejecución. + Los juegos de Steam usan el Límite de fotogramas de Steam en Quick Access. La pantalla cambia a una frecuencia de actualización que el límite divida exactamente, si existe. + El Modo de baja latencia del menú de sesión envía la entrada del control a 1000 Hz en lugar de 250 Hz, a cambio de un poco más de CPU y batería. + Cada juego tiene su propio perfil con Proton, FEX, componentes y ajustes de entorno. + El menú de sesión tiene un interruptor de micrófono para el chat de voz y un botón Suspender ahora para congelar la sesión cuando quieras. + Arrastra el HUD de DroidDeck para moverlo, pellizca para cambiar su tamaño y empújalo contra un borde para acoplarlo como una pequeña pestaña de FPS. + En consolas portátiles de doble pantalla, la pantalla inferior puede mostrar descargas, notificaciones, capturas de pantalla y el chat de Steam. Intercambiar pantallas pone el juego allí. + Añade bibliotecas de Steam desde una tarjeta SD, una unidad USB o un SSD, y DroidDeck mantiene los juegos juntos en tu Biblioteca. + Tiendas te permite iniciar sesión en Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io y Game Jolt, y luego instalar y actualizar sus juegos desde DroidDeck. + Componentes como FEX, DXVK y VKD3D-Proton se actualizan solos, y Proton Experimental ARM64 es el predeterminado, o Proton 11.0 ARM64 una vez instalada esa versión. + Comprimir Steam mientras se ejecuta un juego libera RAM en dispositivos con poca memoria. + Desliza desde el borde derecho para abrir el menú de sesión: modo touchpad, Teclado de PC, Modo de baja latencia, perfil del juego y más. + ¿El juego va lento? Limita la tasa de fotogramas en Quick Access y prueba otra versión de Proton o un ajuste preestablecido de FEX en los componentes del juego. + ¿Audio del juego entrecortado o ausente? Prueba el interruptor DirectAudio para juegos en los ajustes de Steam, en Audio. + Configuración, y luego Almacenamiento, puede borrar cachés de shaders y prefijos sobrantes de juegos que quitaste. + ¿Encontraste un error? Compartir registros en el menú de sesión reúne los datos de diagnóstico. Publícalos en #bug-reports en Discord. - La primera vez se prepara el escritorio. Puede tardar unos minutos. - De forma predeterminada, al salir de la app la sesión se pausa y continúa donde la dejaste cuando vuelves. + La primera ejecución configura el escritorio. Puede tardar unos minutos. El tacto funciona como un touchpad: arrastra para mover el puntero y toca para hacer clic. - Tu mando aparece como un mando Xbox 360. Si no, usa los controles en pantalla. + Comportamiento en segundo plano decide qué pasa al salir de la app: Manual espera a Reanudar de forma predeterminada, Auto pausa y Nunca lo mantiene en ejecución. + Desliza desde el borde derecho para abrir el menú de sesión y elige Teclado de PC para escribir en apps que ignoran el teclado de Android. + El Teclado de PC del menú de sesión tiene tamaño, opacidad y grupos de teclas ajustables. + Tu control aparece como un control Xbox 360. Si no, usa los controles en pantalla. + El menú de sesión tiene un interruptor de micrófono y un botón Suspender ahora para congelar la sesión cuando quieras. + ¿Encontraste un error? Compartir registros en el menú de sesión reúne los datos de diagnóstico. Publícalos en #bug-reports en Discord. Sesión Se muestra mientras hay una sesión de Steam o de escritorio abierta @@ -269,6 +289,10 @@ Touchpad Directo Auto: touchpad en Escritorio, directo en Steam. + Lápiz + Ratón + Táctil + Botón lateral Controles en pantalla Steam + QAM Auto muestra los controles cuando no hay ningún mando conectado. @@ -606,6 +630,8 @@ Desactivado Predeterminado del controlador Comprimir Steam mientras se ejecuta un juego + Comprimir memoria inactiva del juego + Comprime la memoria inactiva del juego cuando queda poca RAM. Desactívalo si los juegos se congelan unos segundos cada medio minuto aproximadamente. Se aplica la próxima vez que se inicie la sesión. 20 s después de que empiece un juego, el cliente de Steam se comprime en zRAM para dejarle más memoria al juego, y se vuelve a leer cuando el juego se cierra. Desactívalo si la sesión se cierra poco después de iniciar los juegos. Un límite de RAM definido arriba sigue comprimiendo Steam cuando la sesión lo supera. Límite de RAM Se aplica mientras se ejecuta el cliente de Steam, en modo Steam o desde el escritorio. Cuando la sesión usa más de esto, Steam y luego los demás procesos compatibles de la sesión se comprimen en zRAM. Es un límite flexible: no se cierra nada, pero los juegos pueden tener tirones mientras se recuperan las páginas. @@ -616,7 +642,7 @@ Solo Adreno. Menos tirones, más consumo de batería y calor. Correcciones de sesión Turnip: renderizado sysmem - Más rápido para el cliente de Steam; en los juegos, el controlador elige entre renderizado por mosaicos o en memoria del sistema en cada pasada. Obligatorio en Adreno 710/720/722. + Se aplica al cliente de Steam y a los juegos. Obligatorio en Adreno 710/720/722. Omitir el asistente xalia de Steam droiddeck-ntsync Un sustituto en espacio de usuario del controlador ntsync de Linux. Mientras está activado, Proton lo usa en lugar de droiddeck-esync y droiddeck-fsync. Funciona con Proton Experimental ARM64, GE-Proton y proton-cachyos. Se aplica en la próxima sesión. @@ -1853,6 +1879,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Borrar Instala primero el runtime La biblioteca de Steam no está disponible La biblioteca anterior de la SD no está disponible @@ -3876,8 +3903,6 @@ Alt+Tab, la tecla Win y el botón Inicio se quedan en la sesión ¿Aparece en gris en Android? Información de la aplicación → ⋮ → Permitir ajustes restringidos Bloqueado por Android · Información de la aplicación → ⋮ → Permitir ajustes restringidos - Teclas del sistema de DroidDeck - Mantiene Alt+Tab, la tecla Win y el botón Inicio en una sesión activa de DroidDeck en lugar de Android. Activa Brillo en Configuración → Integración con Steam Puente Mali: desactivado %1$s no puede usar el puente Mali (necesita una GPU Mali sin ruta de controlador del sistema), así que este interruptor no tiene efecto aquí. @@ -4039,10 +4064,11 @@ Restablecer posiciones Mostrar etiqueta No se ha podido importar esta disposición + Se instala mediante %1$s Nieve escarlata Superficies blancas con acentos rojos. - + Bandas sonoras Música Opciones de reproducción diff --git a/app/src/main/res/values-fi/strings.xml b/app/src/main/res/values-fi/strings.xml index 8d0e351def..e08804e6ee 100644 --- a/app/src/main/res/values-fi/strings.xml +++ b/app/src/main/res/values-fi/strings.xml @@ -10,14 +10,34 @@ DroidDeck Ensimmäinen käynnistys lataa Steamin. Tämä voi kestää muutaman minuutin. - Oletuksena sovelluksesta poistuminen keskeyttää Steamin; se jatkuu siitä mihin jäit, kun palaat takaisin. - Ohjaimesi näkyy Xbox 360 -ohjaimena. Muussa tapauksessa käytä näytön ohjaimia. + Ohjaimesi näkyy Steamille Steam Deck -ohjaimena. Vaihda se Steam Controller-, DualShock 4-, DualSense- tai Xbox 360 -ohjaimeksi istunnon asetuksissa; muutos tulee voimaan seuraavassa istunnossa. + Pidä ohjaimen Takaisin-painiketta pohjassa avataksesi Steamin Pikavalikon. Asetuksen Pidä Takaisin pohjassa Steam-pikanäppäimille on oltava päällä istunnon asetuksissa. + Taustatoiminta määrää, mitä tapahtuu, kun poistut sovelluksesta: Natiivi valmistelee Steamin lepotilaan, Automaattinen keskeyttää sen, Manuaalinen odottaa Jatka-painiketta, Ei koskaan pitää sen käynnissä. + Steam-pelit käyttävät Steamin Kuvanopeusrajaa Pikavalikossa. Näyttö vaihtaa virkistystaajuuteen, jolla raja jakautuu tasan, jos sellainen on. + Matalan viiveen tila istuntovalikossa lähettää ohjaimen syötteen 1000 Hz:n taajuudella 250 Hz:n sijaan, hieman suuremmalla suoritin- ja akunkulutuksella. + Jokaisella pelillä on oma profiilinsa, jossa on Proton-, FEX-, komponentti- ja ympäristöasetukset. + Istuntovalikossa on mikrofonin kytkin puhekeskustelua varten ja Keskeytä nyt -painike istunnon jäädyttämiseen tarvittaessa. + Siirrä DroidDeckin HUD vetämällä, muuta sen kokoa nipistämällä ja telakoi se pieneksi FPS-välilehdeksi työntämällä se reunan yli. + Kaksinäyttöisissä käsikonsoleissa alanäyttö voi näyttää lataukset, ilmoitukset, kuvakaappaukset ja Steam-chatin. Vaihda näytöt siirtää pelin sinne. + Lisää Steam-kirjastoja SD-kortilta, USB-asemalta tai SSD-levyltä, ja DroidDeck pitää pelit yhdessä Kirjastossasi. + Kaupat-osiossa voit kirjautua sisään palveluihin Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io ja Game Jolt sekä asentaa ja päivittää niiden pelejä DroidDeckistä. + Komponentit, kuten FEX, DXVK ja VKD3D-Proton, päivittyvät itsestään, ja oletuksena on Proton Experimental ARM64 tai Proton 11.0 ARM64, kun kyseinen versio on asennettu. + Pakkaa Steam pelin ollessa käynnissä vapauttaa RAM-muistia laitteilla, joilla muisti on vähissä. + Pyyhkäise oikeasta reunasta sisäänpäin avataksesi istuntovalikon: kosketuslevytila, PC-näppäimistö, matalan viiveen tila, pelin profiili ja muuta. + Peli pyörii hitaasti? Rajoita kuvanopeutta Pikavalikossa ja kokeile sitten toista Proton-versiota tai FEX-esiasetusta pelin komponenteissa. + Rätisevä tai puuttuva pelin ääni? Kokeile Steamin asetuksissa kohdassa Ääni asetusta DirectAudio peleille. + Asetukset ja sen alla Tallennustila voi tyhjentää shader-välimuistit ja poistettujen pelien jäljelle jääneet prefixit. + Osuitko virheeseen? Jaa lokit istuntovalikossa kokoaa diagnostiikkatiedot. Julkaise ne kanavalla #bug-reports Discordissa. - Ensimmäinen käynnistys määrittää työpöydän. Tämä voi kestää muutaman minuutin. - Oletuksena sovelluksesta poistuminen keskeyttää istunnon; se jatkuu siitä mihin jäit, kun palaat takaisin. - Kosketus toimii kosketuslevynä: vedä liikuttaaksesi osoitinta, napauta napsauttaaksesi. - Ohjaimesi näkyy Xbox 360 -ohjaimena. Muussa tapauksessa käytä näytön ohjaimia. + Ensimmäinen käynnistys valmistelee työpöydän. Tämä voi kestää muutaman minuutin. + Kosketus toimii kosketuslevynä: siirrä osoitinta vetämällä, napsauta napauttamalla. + Taustatoiminta määrää, mitä tapahtuu, kun poistut sovelluksesta: Manuaalinen odottaa oletuksena Jatka-painiketta, Automaattinen keskeyttää, Ei koskaan pitää käynnissä. + Pyyhkäise oikeasta reunasta sisäänpäin avataksesi istuntovalikon ja valitse PC-näppäimistö kirjoittaaksesi sovelluksissa, jotka ohittavat Androidin näppäimistön. + Istuntovalikon PC-näppäimistön koko, peittävyys ja näppäinryhmät ovat säädettävissä. + Ohjaimesi näkyy Xbox 360 -ohjaimena. Muuten käytä näytön ohjaimia. + Istuntovalikossa on mikrofonin kytkin ja Keskeytä nyt -painike istunnon jäädyttämiseen tarvittaessa. + Osuitko virheeseen? Jaa lokit istuntovalikossa kokoaa diagnostiikkatiedot. Julkaise ne kanavalla #bug-reports Discordissa. Istunto Näkyy, kun Steam- tai työpöytäistunto on käynnissä @@ -269,6 +289,10 @@ Kosketuslevy Suora Automaattinen: kosketuslevy Työpöydällä, suora Steamissa. + Kynä + Hiiri + Kosketus + Sivupainike Näytön ohjaimet Steam + QAM Automaattinen näyttää ohjaimet, kun yhtään ohjainta ei ole kytketty. @@ -604,6 +628,8 @@ Pois Ajurin oletus Pakkaa Steam pelin ollessa käynnissä + Pakkaa pelin käyttämätöntä muistia + Siirtää pelin käyttämätöntä muistia zRAMiin, kun RAM-muisti vähenee. Poista tämä käytöstä, jos pelit jäätyvät muutamaksi sekunniksi noin puolen minuutin välein. Tulee voimaan, kun istunto käynnistyy seuraavan kerran. 20 s pelin käynnistymisen jälkeen Steam-asiakasohjelma pakataan zRAMiin, jotta pelille jää enemmän muistia, ja luetaan takaisin, kun peli sulkeutuu. Poista tämä käytöstä, jos istunto sulkeutuu pian pelien käynnistymisen jälkeen. Yllä oleva RAM-raja pakkaa silti Steamin, kun istunto ylittää sen. RAM-raja Koskee aikaa, jolloin Steam-asiakasohjelma on käynnissä, Steam-tilassa tai työpöydältä. Kun istunto käyttää tätä enemmän, Steam ja sen jälkeen istunnon muut tuetut prosessit pakataan zRAMiin. Pehmeä raja: mitään ei suljeta, mutta pelit voivat nykiä, kun sivuja luetaan takaisin. @@ -614,7 +640,7 @@ Vain Adreno. Vähemmän nykäyksiä, enemmän akun kulutusta ja lämpöä. Istunnon korjaukset Turnip: sysmem-renderöinti - Nopeampi Steam-asiakasohjelmalle; peleissä ajuri valitsee jokaiselle vaiheelle ruuduittaisen tai järjestelmämuistiin tehtävän renderöinnin. Pakollinen Adreno 710/720/722:lla. + Koskee Steam-asiakasohjelmaa ja pelejä. Pakollinen Adreno 710/720/722:lla. Ohita Steamin xalia-avustaja droiddeck-ntsync Käyttäjätilainen korvike Linuxin ntsync-ajurille. Kun se on päällä, Proton käyttää sitä droiddeck-esyncin ja droiddeck-fsyncin sijaan. Toimii Proton Experimental ARM64:n, GE-Protonin ja proton-cachyosin kanssa. Tulee voimaan seuraavassa istunnossa. @@ -1834,6 +1860,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Tyhjennä Asenna ajoympäristö ensin Steam-kirjasto ei ole käytettävissä Aiempi SD-kirjasto ei ole käytettävissä @@ -3837,8 +3864,6 @@ Alt+Tab, Win-näppäin ja Koti-painike pysyvät istunnossa Harmaana Androidissa? Sovelluksen tiedot → ⋮ → Salli rajoitetut asetukset Androidin estämä · Sovelluksen tiedot → ⋮ → Salli rajoitetut asetukset - DroidDeckin järjestelmänäppäimet - Pitää Alt+Tabin, Win-näppäimen ja Koti-painikkeen aktiivisessa DroidDeck-istunnossa Androidin sijaan. Ota Kirkkaus käyttöön kohdassa Käyttöönotto → Steam-integraatio Mali-silta: pois %1$s ei voi käyttää Mali-siltaa (se vaatii Mali-GPU:n, jolla ei ole järjestelmäajurireittiä), joten tällä kytkimellä ei ole vaikutusta tässä. @@ -3999,10 +4024,11 @@ Palauta sijainnit Näytä nimi Tätä asettelua ei voitu tuoda + Asennetaan sovelluksen %1$s kautta Helakanpunainen lumi Valkoiset pinnat punaisin korostuksin. - + Soundtrackit Musiikki Toistoasetukset diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index b2752c83c2..3d8b752b25 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -10,14 +10,34 @@ DroidDeck Le premier lancement télécharge Steam. Cela peut prendre quelques minutes. - Par défaut, quitter l\'application met Steam en pause ; y revenir reprend là où vous vous étiez arrêté. - Votre manette apparaîtra comme une manette Xbox 360. Sinon, utilisez les commandes à l\'écran. + Votre manette apparaît dans Steam comme une manette Steam Deck. Passez à une manette Steam Controller, DualShock 4, DualSense ou Xbox 360 dans les paramètres de session ; le changement s\'applique à la session suivante. + Maintenez Retour sur votre manette pour ouvrir le menu Accès rapide de Steam. L\'option Maintenir Retour pour les raccourcis Steam doit être activée dans les paramètres de session. + Comportement en arrière-plan détermine ce qui se passe quand vous quittez l\'application : Natif prépare Steam à la mise en veille, Auto le met en pause, Manuel attend Reprendre, Jamais le laisse tourner. + Les jeux Steam utilisent la Limite d\'images de Steam dans Accès rapide. L\'écran passe à une fréquence de rafraîchissement que la limite divise exactement, s\'il en existe une. + Le Mode faible latence du menu de session envoie les commandes de la manette à 1000 Hz au lieu de 250 Hz, pour un peu plus de CPU et de batterie. + Chaque jeu a son propre profil avec Proton, FEX, composants et paramètres d\'environnement. + Le menu de session propose un bouton micro pour le chat vocal et un bouton Mettre en pause maintenant pour figer la session à la demande. + Faites glisser le HUD DroidDeck pour le déplacer, pincez pour le redimensionner, et poussez-le hors d\'un bord pour l\'ancrer en petit onglet FPS. + Sur les consoles portables à double écran, l\'écran du bas peut afficher les téléchargements, les notifications, les captures d\'écran et le chat Steam. Inverser les écrans y place le jeu à la place. + Ajoutez des bibliothèques Steam depuis une carte SD, une clé USB ou un SSD, et DroidDeck réunit les jeux dans votre Bibliothèque. + Boutiques vous permet de vous connecter à Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io et Game Jolt, puis d\'installer et de mettre à jour leurs jeux depuis DroidDeck. + Les composants comme FEX, DXVK et VKD3D-Proton se mettent à jour seuls, et Proton Experimental ARM64 est la valeur par défaut, ou Proton 11.0 ARM64 une fois cette version installée. + Compresser Steam pendant un jeu libère de la RAM sur les appareils qui en manquent. + Balayez depuis le bord droit pour ouvrir le menu de session : mode pavé tactile, Clavier PC, Mode faible latence, Profil du jeu et plus encore. + Jeu lent ? Limitez la fréquence d\'images dans Accès rapide, puis essayez une autre version de Proton ou un autre préréglage FEX dans les composants du jeu. + Audio du jeu qui grésille ou absent ? Essayez l\'option Utiliser DirectAudio pour le jeu dans les paramètres Steam, sous Audio. + Configuration, puis Stockage, peut effacer les caches de shaders et les préfixes restants des jeux supprimés. + Un bug ? Partager les journaux dans le menu de session regroupe les diagnostics. Publiez-les dans #bug-reports sur Discord. Le premier lancement configure le bureau. Cela peut prendre quelques minutes. - Par défaut, quitter l\'application met la session en pause ; y revenir reprend là où vous vous étiez arrêté. - Le tactile fonctionne comme un pavé tactile : faites glisser pour déplacer le pointeur, tapotez pour cliquer. - Votre manette apparaîtra comme une manette Xbox 360. Sinon, utilisez les commandes à l\'écran. + Le tactile fonctionne comme un pavé tactile : faites glisser pour déplacer le pointeur, touchez pour cliquer. + Comportement en arrière-plan détermine ce qui se passe quand vous quittez l\'application : Manuel attend Reprendre par défaut, Auto met en pause, Jamais laisse tourner. + Balayez depuis le bord droit pour ouvrir le menu de session, puis choisissez Clavier PC pour saisir du texte dans les applis qui ignorent le clavier Android. + Le Clavier PC du menu de session a une taille, une opacité et des groupes de touches réglables. + Votre manette apparaît comme une manette Xbox 360. Sinon, utilisez les commandes à l\'écran. + Le menu de session propose un bouton micro et un bouton Mettre en pause maintenant pour figer la session à la demande. + Un bug ? Partager les journaux dans le menu de session regroupe les diagnostics. Publiez-les dans #bug-reports sur Discord. Session Affiché lorsqu\'une session Steam ou Bureau est ouverte @@ -269,6 +289,10 @@ Pavé tactile Direct Auto : pavé tactile pour le bureau, tactile direct pour Steam. + Stylet + Souris + Tactile + Bouton latéral Commandes à l\'écran Steam + QAM Le mode automatique affiche les commandes à l\'écran lorsqu\'aucune manette n\'est connectée. @@ -606,6 +630,8 @@ Désactivé Valeur par défaut du pilote Compresser Steam pendant un jeu + Compresser la mémoire inactive du jeu + Compresse la mémoire inactive du jeu quand la RAM manque. Désactivez-le si les jeux se figent quelques secondes environ toutes les trente secondes. S\'applique au prochain démarrage de la session. 20 s après le démarrage d\'un jeu, le client Steam est compressé dans zRAM pour laisser plus de mémoire au jeu, puis relu à la fermeture du jeu. Désactivez cette option si la session se ferme peu après le démarrage des jeux. Une limite de RAM ci-dessus compresse toujours Steam lorsque la session la dépasse. Limite de RAM S\'applique tant que le client Steam fonctionne, en mode Steam ou depuis le bureau. Lorsque la session dépasse cette valeur, Steam puis les autres processus pris en charge de la session sont compressés dans zRAM. Limite souple : rien n\'est fermé, mais les jeux peuvent saccader pendant le rechargement des pages. @@ -616,7 +642,7 @@ Uniquement pour Adreno. Moins de saccades, mais plus de consommation d\'énergie et de chaleur. Correctifs de session Turnip : rendu sysmem - Le client Steam sera plus rapide ; en jeu, le pilote choisit à chaque passe entre rendu par tuiles et rendu en mémoire système. Requis pour Adreno 710/720/722. + S’applique au client Steam et aux jeux. Requis sur Adreno 710/720/722. Ignorer l\'assistant xalia de Steam droiddeck-ntsync Un substitut en espace utilisateur du pilote Linux ntsync. Lorsqu\'il est activé, Proton l\'utilise à la place de droiddeck-esync et de droiddeck-fsync. Fonctionne avec Proton Experimental ARM64, GE-Proton et proton-cachyos. Prendra effet à la prochaine session. @@ -1852,6 +1878,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Effacer Installez d\'abord l\'environnement d\'exécution La bibliothèque Steam n\'est pas disponible L\'ancienne bibliothèque SD n\'est pas disponible @@ -3875,8 +3902,6 @@ Alt+Tab, la touche Win et le bouton Accueil restent dans la session Grisé dans Android ? Infos sur l\'appli → ⋮ → Autoriser les paramètres restreints Bloqué par Android · Infos sur l\'appli → ⋮ → Autoriser les paramètres restreints - Touches système DroidDeck - Garde Alt+Tab, la touche Win et le bouton Accueil dans une session DroidDeck active plutôt que dans Android. Activez Luminosité dans Paramètres → Intégration Steam Pont Mali : désactivé %1$s ne peut pas utiliser le pont Mali (il faut un GPU Mali sans route de pilote système) ; ce commutateur n\'a donc aucun effet ici. @@ -4038,10 +4063,11 @@ Réinitialiser les positions Afficher le libellé Impossible d’importer cette disposition + S’installe via %1$s Neige écarlate Surfaces blanches avec des accents rouges. - + Bandes originales Musique Options de lecture diff --git a/app/src/main/res/values-hi/strings.xml b/app/src/main/res/values-hi/strings.xml index 87be428351..2b745ec06c 100644 --- a/app/src/main/res/values-hi/strings.xml +++ b/app/src/main/res/values-hi/strings.xml @@ -10,14 +10,34 @@ DroidDeck पहली बार चलाने पर Steam डाउनलोड होता है। इसमें कुछ मिनट लग सकते हैं। - डिफ़ॉल्ट रूप से, ऐप से बाहर जाने पर Steam रुक जाता है; वापस आने पर यह वहीं से शुरू होता है जहां छोड़ा था। - आपका कंट्रोलर Xbox 360 पैड के रूप में दिखाई देता है। नहीं तो, ऑन-स्क्रीन कंट्रोल का उपयोग करें। + आपका कंट्रोलर Steam को Steam Deck कंट्रोलर के रूप में दिखता है। सत्र सेटिंग में इसे Steam Controller, DualShock 4, DualSense या Xbox 360 पैड पर बदलें; यह अगले सत्र से लागू होता है। + Steam का Quick Access मेनू खोलने के लिए अपने कंट्रोलर पर बैक दबाकर रखें। सत्र सेटिंग में Steam शॉर्टकट के लिए बैक दबाकर रखें चालू होना चाहिए। + बैकग्राउंड व्यवहार तय करता है कि ऐप छोड़ने पर क्या होता है: नेटिव Steam को स्लीप के लिए तैयार करता है, ऑटो उसे रोक देता है, मैनुअल फिर से शुरू करें का इंतज़ार करता है, कभी नहीं उसे चलता रखता है। + Steam गेम Quick Access में Steam की फ़्रेम सीमा का उपयोग करते हैं। अगर कोई ऐसा रिफ्रेश रेट हो जिससे सीमा बराबर बँट जाए, तो डिस्प्ले उसी पर चला जाता है। + सत्र मेनू में लो लेटेंसी मोड कंट्रोलर इनपुट को 250 Hz की जगह 1000 Hz पर भेजता है, जिसके लिए थोड़ा ज़्यादा CPU और बैटरी लगती है। + हर गेम की अपनी प्रोफ़ाइल होती है, जिसमें Proton, FEX, कॉम्पोनेंट और एनवायरनमेंट सेटिंग शामिल हैं। + सत्र मेनू में वॉइस चैट के लिए माइक्रोफ़ोन टॉगल और ज़रूरत पर सत्र को फ़्रीज़ करने के लिए अभी सस्पेंड करें बटन है। + DroidDeck HUD को हिलाने के लिए खींचें, आकार बदलने के लिए पिंच करें, और छोटे FPS टैब के रूप में डॉक करने के लिए उसे किनारे से बाहर धकेलें। + दो स्क्रीन वाले हैंडहेल्ड पर निचली स्क्रीन डाउनलोड, नोटिफ़िकेशन, स्क्रीनशॉट और Steam चैट दिखा सकती है। स्क्रीन बदलें गेम को वहाँ रख देता है। + SD कार्ड, USB ड्राइव या SSD से Steam लाइब्रेरी जोड़ें, और DroidDeck गेम को आपकी लाइब्रेरी में एक साथ रखता है। + स्टोर से आप Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io और Game Jolt में साइन इन कर सकते हैं, फिर DroidDeck से उनके गेम इंस्टॉल और अपडेट कर सकते हैं। + FEX, DXVK और VKD3D-Proton जैसे कॉम्पोनेंट खुद अपडेट होते हैं, और डिफ़ॉल्ट Proton Experimental ARM64 है, या वह बिल्ड इंस्टॉल होने पर Proton 11.0 ARM64। + गेम चलते समय Steam को कंप्रेस करें कम RAM वाले डिवाइस पर RAM खाली करता है। + सत्र मेनू खोलने के लिए दाएँ किनारे से अंदर की ओर स्वाइप करें: टचपैड मोड, पीसी कीबोर्ड, लो लेटेंसी मोड, गेम प्रोफ़ाइल और बहुत कुछ। + गेम धीमा चल रहा है? Quick Access में फ़्रेम रेट सीमित करें, फिर गेम के कॉम्पोनेंट में कोई दूसरा Proton वर्शन या FEX प्रीसेट आज़माएँ। + गेम की आवाज़ में खरखराहट है या आवाज़ नहीं आ रही? Steam सेटिंग में ऑडियो के अंतर्गत गेम के लिए DirectAudio टॉगल आज़माएँ। + सेटअप में स्टोरेज से शेडर कैश और हटाए गए गेम के बचे हुए प्रीफ़िक्स साफ़ किए जा सकते हैं। + कोई बग मिला? सत्र मेनू में लॉग शेयर करें डायग्नोस्टिक्स का बंडल बनाता है। उन्हें Discord पर #bug-reports में पोस्ट करें। - पहली बार चलाने पर डेस्कटॉप सेट हो जाता है। इसमें कुछ मिनट लग सकते हैं। - डिफ़ॉल्ट रूप से, ऐप से बाहर जाने पर सेशन रुक जाता है; वापस आने पर यह वहीं से शुरू होता है जहां छोड़ा था। - टच टचपैड की तरह काम करता है: पॉइंटर घुमाने के लिए ड्रैग करें, क्लिक के लिए टैप करें। - आपका कंट्रोलर Xbox 360 पैड के रूप में दिखाई देता है। नहीं तो, ऑन-स्क्रीन कंट्रोल का उपयोग करें। + पहली बार चलाने पर डेस्कटॉप सेट अप होता है। इसमें कुछ मिनट लग सकते हैं। + टच टचपैड की तरह काम करता है: पॉइंटर हिलाने के लिए खींचें, क्लिक करने के लिए टैप करें। + बैकग्राउंड व्यवहार तय करता है कि ऐप छोड़ने पर क्या होता है: मैनुअल डिफ़ॉल्ट रूप से फिर से शुरू करें का इंतज़ार करता है, ऑटो रोक देता है, कभी नहीं चलता रखता है। + सत्र मेनू खोलने के लिए दाएँ किनारे से अंदर की ओर स्वाइप करें, फिर उन ऐप में टाइप करने के लिए पीसी कीबोर्ड चुनें जो Android कीबोर्ड को अनदेखा करते हैं। + सत्र मेनू के पीसी कीबोर्ड का आकार, अपारदर्शिता और कुंजी समूह बदले जा सकते हैं। + आपका कंट्रोलर Xbox 360 पैड के रूप में दिखता है। नहीं तो ऑन-स्क्रीन कंट्रोल का उपयोग करें। + सत्र मेनू में माइक्रोफ़ोन टॉगल और ज़रूरत पर सत्र को फ़्रीज़ करने के लिए अभी सस्पेंड करें बटन है। + कोई बग मिला? सत्र मेनू में लॉग शेयर करें डायग्नोस्टिक्स का बंडल बनाता है। उन्हें Discord पर #bug-reports में पोस्ट करें। सेशन Steam या डेस्कटॉप सेशन खुला होने पर दिखता है @@ -269,6 +289,10 @@ टचपैड डायरेक्ट ऑटो: डेस्कटॉप पर टचपैड, Steam में डायरेक्ट। + पेन + माउस + टच + साइड बटन ऑन-स्क्रीन कंट्रोल Steam + QAM कोई कंट्रोलर कनेक्ट न होने पर ऑटो कंट्रोल दिखाता है। @@ -604,6 +628,8 @@ बंद ड्राइवर डिफ़ॉल्ट गेम चलते समय Steam को कंप्रेस करें + गेम की निष्क्रिय मेमोरी को संपीड़ित करें + RAM कम होने पर गेम की निष्क्रिय मेमोरी को पेज करता है। अगर गेम लगभग हर आधे मिनट में कुछ सेकंड के लिए रुकते हैं, तो इसे बंद करें। अगली बार सत्र शुरू होने पर लागू होता है। गेम शुरू होने के 20 s बाद, Steam क्लाइंट को zRAM में कंप्रेस किया जाता है ताकि गेम को ज़्यादा मेमोरी मिले, और गेम बंद होने पर वापस पढ़ा जाता है। अगर गेम शुरू होने के कुछ देर बाद सेशन बंद हो जाता है तो इसे बंद करें। ऊपर दी गई RAM सीमा पार होने पर भी Steam कंप्रेस होता है। RAM सीमा Steam क्लाइंट चलते समय लागू होती है, Steam मोड में या डेस्कटॉप से। जब सेशन इससे ज़्यादा इस्तेमाल करता है, तो Steam और फिर सेशन की दूसरी समर्थित प्रोसेस zRAM में कंप्रेस होती हैं। यह सॉफ़्ट सीमा है: कुछ बंद नहीं होता, लेकिन पेज वापस आते समय गेम अटक सकते हैं। @@ -614,7 +640,7 @@ सिर्फ़ Adreno के लिए। कम हिचकोले, लेकिन ज़्यादा बैटरी खर्च और गर्मी। सेशन फ़िक्स Turnip: sysmem रेंडरिंग - Steam क्लाइंट के लिए तेज़; गेम में ड्राइवर हर पास के लिए टाइल या सिस्टम मेमोरी रेंडरिंग चुनता है। Adreno 710/720/722 पर ज़रूरी। + Steam क्लाइंट और गेम पर लागू। Adreno 710/720/722 पर ज़रूरी। Steam के xalia हेल्पर को छोड़ें droiddeck-ntsync Linux ntsync ड्राइवर की यूज़रस्पेस जगह लेने वाली चीज़। चालू रहते हुए, Proton इसे droiddeck-esync और droiddeck-fsync के बदले इस्तेमाल करता है। यह Proton Experimental ARM64, GE-Proton और proton-cachyos के साथ काम करता है। अगले सेशन से लागू होता है। @@ -1834,6 +1860,7 @@ %1$s ✓ Ctrl+C Ctrl+D + साफ़ करें पहले रनटाइम इंस्टॉल करें Steam लाइब्रेरी उपलब्ध नहीं है पिछली SD लाइब्रेरी उपलब्ध नहीं है @@ -3837,8 +3864,6 @@ Alt+Tab, Win कुंजी और होम बटन सत्र में ही रहते हैं Android में धूसर है? ऐप्लिकेशन की जानकारी → ⋮ → प्रतिबंधित सेटिंग की अनुमति दें Android ने ब्लॉक किया · ऐप्लिकेशन की जानकारी → ⋮ → प्रतिबंधित सेटिंग की अनुमति दें - DroidDeck सिस्टम कुंजियाँ - Alt+Tab, Win कुंजी और होम बटन को Android के बजाय सक्रिय DroidDeck सत्र में रखता है। Setup → Steam इंटीग्रेशन में ब्राइटनेस चालू करें Mali ब्रिज: बंद %1$s Mali ब्रिज इस्तेमाल नहीं कर सकता (इसे ऐसा Mali GPU चाहिए जिसके पास सिस्टम ड्राइवर का रास्ता न हो), इसलिए यहाँ इस स्विच का कोई असर नहीं है। @@ -3999,10 +4024,11 @@ स्थितियाँ रीसेट करें लेबल दिखाएँ यह लेआउट इम्पोर्ट नहीं किया जा सका + %1$s के ज़रिए इंस्टॉल होता है किरमिज़ी बर्फ लाल रंग की झलकियों वाली सफ़ेद सतहें। - + साउंडट्रैक संगीत प्लेबैक विकल्प diff --git a/app/src/main/res/values-hu/strings.xml b/app/src/main/res/values-hu/strings.xml index f99551869c..4846ffabc4 100644 --- a/app/src/main/res/values-hu/strings.xml +++ b/app/src/main/res/values-hu/strings.xml @@ -9,15 +9,35 @@ A DroidDeck nem tudott automatikusan újraindulni. Zárja be teljesen az alkalmazást, majd nyissa meg újra. DroidDeck - Az első indítás letölti a Steamet. Ez néhány percet vehet igénybe. - Alapértelmezés szerint az alkalmazás elhagyása szünetelteti a Steamet; visszatéréskor ott folytatja, ahol abbahagyta. - A kontroller Xbox 360 kontrollerként jelenik meg. Egyébként használja a képernyőn lévő vezérlőket. + Az első indításkor letöltődik a Steam. Ez eltarthat néhány percig. + A kontrollered Steam Deck kontrollerként jelenik meg a Steam számára. A munkamenet beállításaiban átállíthatod Steam Controller, DualShock 4, DualSense vagy Xbox 360 kontrollerre; a változás a következő munkamenettől él. + Tartsd nyomva a kontrolleren a Vissza gombot a Steam Gyors hozzáférés menüjének megnyitásához. A Vissza nyomva tartása Steam parancsokhoz beállításnak bekapcsolva kell lennie a munkamenet beállításaiban. + A Háttérbeli viselkedés dönti el, mi történik, ha elhagyod az alkalmazást: a Natív felkészíti a Steamet az altatásra, az Automatikus szüneteltet, a Manuális megvárja a Folytatást, a Soha futva tartja. + A Steam-játékok a Steam Képkockakorlátját használják a Gyors hozzáférésben. A kijelző olyan frissítési gyakoriságra vált, amellyel a korlát egyenletesen osztható, ha van ilyen. + A munkamenet menü Alacsony késleltetésű módja 250 Hz helyett 1000 Hz-cel küldi a kontroller bemenetét, kicsit több CPU- és akkumulátorhasználat árán. + Minden játéknak saját profilja van a Proton, FEX, összetevők és környezeti beállítások számára. + A munkamenet menüben van egy mikrofonkapcsoló a hangchathez, és egy Felfüggesztés most gomb a munkamenet igény szerinti befagyasztásához. + Húzd odébb a DroidDeck HUD-ot a mozgatáshoz, csípéssel méretezd át, és told ki a szélén túlra, hogy kis FPS-fülként rögzüljön. + Dupla kijelzős kézikonzolokon az alsó kijelző letöltéseket, értesítéseket, képernyőképeket és Steam-csevegést mutathat. A kijelzők cseréje oda teszi át a játékot. + Adj hozzá Steam-könyvtárakat SD-kártyáról, USB-meghajtóról vagy SSD-ről, és a DroidDeck egy helyen tartja a játékokat a Könyvtárban. + Az Áruházak lehetővé teszi, hogy bejelentkezz a Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io és Game Jolt szolgáltatásokba, majd telepítsd és frissítsd a játékaikat a DroidDeckből. + Az olyan összetevők, mint a FEX, a DXVK és a VKD3D-Proton, maguktól frissülnek, az alapértelmezett pedig a Proton Experimental ARM64, vagy a Proton 11.0 ARM64, ha az a build telepítve van. + A Steam tömörítése játék közben RAM-ot szabadít fel a kevés memóriával rendelkező eszközökön. + Húzd be az ujjad a jobb szélről a munkamenet menü megnyitásához: érintőpad mód, PC-billentyűzet, alacsony késleltetésű mód, játékprofil és más. + Lassan fut a játék? Korlátozd a képkockasebességet a Gyors hozzáférésben, majd próbálj ki másik Proton-verziót vagy FEX-előbeállítást a játék összetevőiben. + Ropog vagy hiányzik a játék hangja? Próbáld ki a DirectAudio a játékokhoz kapcsolót a Steam beállításaiban a Hang alatt. + A Beállítás, azon belül a Tárhely törölheti a shader-gyorsítótárakat és az eltávolított játékok megmaradt prefixeit. + Hibába futottál? A munkamenet menü Naplók megosztása pontja összegyűjti a diagnosztikát. Tedd közzé a Discord #bug-reports csatornáján. - Az első indítás beállítja az asztalt. Ez néhány percet vehet igénybe. - Alapértelmezés szerint az alkalmazás elhagyása szünetelteti a munkamenetet; visszatéréskor ott folytatja, ahol abbahagyta. - Az érintés érintőpadként működik: húzással mozgathatja a kurzort, koppintással kattinthat. - A kontroller Xbox 360 kontrollerként jelenik meg. Egyébként használja a képernyőn lévő vezérlőket. + Az első indításkor beállítódik az asztal. Ez eltarthat néhány percig. + Az érintés érintőpadként működik: húzással mozgathatod a mutatót, koppintással kattinthatsz. + A Háttérbeli viselkedés dönti el, mi történik, ha elhagyod az alkalmazást: a Manuális alapból megvárja a Folytatást, az Automatikus szüneteltet, a Soha futva tartja. + Húzd be az ujjad a jobb szélről a munkamenet menü megnyitásához, majd válaszd a PC-billentyűzet pontot az Android billentyűzetet figyelmen kívül hagyó alkalmazásokban való gépeléshez. + A munkamenet menü PC-billentyűzetének mérete, átlátszatlansága és billentyűcsoportjai állíthatók. + A kontrollered Xbox 360 kontrollerként jelenik meg. Ha nem, használd a képernyőn lévő vezérlőket. + A munkamenet menüben van egy mikrofonkapcsoló és egy Felfüggesztés most gomb a munkamenet igény szerinti befagyasztásához. + Hibába futottál? A munkamenet menü Naplók megosztása pontja összegyűjti a diagnosztikát. Tedd közzé a Discord #bug-reports csatornáján. Munkamenet Megjelenik, amíg egy Steam- vagy asztali munkamenet aktív @@ -269,6 +289,10 @@ Érintőpad Közvetlen Automatikus: érintőpad az Asztalon, közvetlen a Steamben. + Toll + Egér + Érintés + Oldalsó gomb Képernyőn megjelenő vezérlők Steam + QAM Az Automatikus megjeleníti a vezérlőket, ha nincs csatlakoztatott kontroller. @@ -604,6 +628,8 @@ Ki Illesztőprogram alapértéke A Steam tömörítése játék közben + Játék inaktív memóriájának tömörítése + Kevés RAM esetén tömöríti a játék inaktív memóriáját. Kapcsold ki, ha a játékok nagyjából félpercenként néhány másodpercre lefagynak. A munkamenet következő indításakor lép érvénybe. 20 mp-cel a játék indulása után a Steam-kliens a zRAM-ba tömörül, hogy több memória maradjon a játéknak, és a játék bezárásakor visszaolvasódik. Kapcsolja ki, ha a munkamenet röviddel a játékok indulása után bezárul. A fenti RAM-korlát akkor is tömöríti a Steamet, ha a munkamenet túllépi. RAM-korlát Akkor érvényes, amikor a Steam-kliens fut, Steam módban vagy az asztalról. Ha a munkamenet ennél többet használ, a Steam, majd a munkamenet többi támogatott folyamata a zRAM-ba tömörül. Puha korlát: semmi sem zárul be, de a játékok akadhatnak, amíg a lapok visszatöltődnek. @@ -614,7 +640,7 @@ Csak Adreno. Kevesebb akadás, nagyobb akkumulátorhasználat és hőtermelés. Munkamenet-javítások Turnip: sysmem renderelés - Gyorsabb a Steam kliensnek; játékokban a meghajtó menetenként választ a csempés és a rendszermemóriás renderelés között. Adreno 710/720/722-n szükséges. + A Steam kliensre és a játékokra vonatkozik. Adreno 710/720/722-n szükséges. A Steam xalia segítőjének kihagyása droiddeck-ntsync A Linux ntsync illesztőprogram felhasználói szintű helyettesítője. Amíg be van kapcsolva, a Proton ezt használja a droiddeck-esync és a droiddeck-fsync helyett. A Proton Experimental ARM64-gyel, a GE-Protonnal és a proton-cachyosszal működik. A következő munkamenettől érvényes. @@ -1834,6 +1860,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Törlés Előbb telepítse a futtatókörnyezetet A Steam-könyvtár nem elérhető A korábbi SD-könyvtár nem elérhető @@ -3837,8 +3864,6 @@ Az Alt+Tab, a Win billentyű és a Kezdőlap gomb a munkamenetben marad Szürke az Androidban? Alkalmazásinformáció → ⋮ → Korlátozott beállítások engedélyezése Az Android letiltotta · Alkalmazásinformáció → ⋮ → Korlátozott beállítások engedélyezése - DroidDeck rendszerbillentyűk - Az Alt+Tab, a Win billentyű és a Kezdőlap gomb az aktív DroidDeck-munkamenetben marad az Android helyett. Kapcsolja be a Fényerőt itt: Beállítás → Steam-integráció Mali híd: ki %1$s nem használhatja a Mali hidat (ehhez olyan Mali GPU kell, amelyhez nincs rendszer-illesztőprogramos útvonal), ezért ennek a kapcsolónak itt nincs hatása. @@ -3999,10 +4024,11 @@ Pozíciók visszaállítása Címke megjelenítése Ez az elrendezés nem importálható + A telepítés itt történik: %1$s Skarlátvörös hó Fehér felületek piros kiemelésekkel. - + Soundtrackek Zene Lejátszási beállítások diff --git a/app/src/main/res/values-in/strings.xml b/app/src/main/res/values-in/strings.xml index 9c81a06c3f..1dfc7a8f2a 100644 --- a/app/src/main/res/values-in/strings.xml +++ b/app/src/main/res/values-in/strings.xml @@ -9,15 +9,35 @@ DroidDeck tidak bisa dimulai ulang secara otomatis. Tutup aplikasi sepenuhnya, lalu buka lagi. DroidDeck - Proses pertama mengunduh Steam. Ini mungkin memerlukan beberapa menit. - Secara default, keluar dari aplikasi akan menjeda Steam; sesi dilanjutkan dari posisi terakhir saat Anda kembali. - Pengontrol Anda akan terlihat sebagai gamepad Xbox 360. Jika tidak, gunakan kontrol di layar. + Saat pertama kali dijalankan, Steam akan diunduh. Ini mungkin memerlukan beberapa menit. + Kontrolermu terlihat oleh Steam sebagai kontroler Steam Deck. Ubah menjadi pad Steam Controller, DualShock 4, DualSense, atau Xbox 360 di pengaturan sesi; perubahan berlaku pada sesi berikutnya. + Tahan Kembali di kontrolermu untuk membuka menu Akses cepat Steam. Tahan Kembali untuk pintasan Steam harus aktif di pengaturan sesi. + Perilaku latar belakang menentukan apa yang terjadi saat kamu meninggalkan aplikasi: Native menyiapkan Steam untuk tidur, Otomatis menjedanya, Manual menunggu Lanjutkan, Tidak pernah membiarkannya tetap berjalan. + Gim Steam memakai Batas frame Steam di Akses cepat. Layar beralih ke refresh rate yang dapat dibagi rata oleh batas tersebut jika ada. + Mode latensi rendah di menu sesi mengirim input kontroler pada 1000 Hz, bukan 250 Hz, dengan sedikit tambahan penggunaan CPU dan baterai. + Setiap gim punya profilnya sendiri dengan Proton, FEX, komponen, dan pengaturan lingkungan. + Menu sesi memiliki tombol mikrofon untuk obrolan suara dan tombol Jeda sekarang untuk membekukan sesi sesuai permintaan. + Seret HUD DroidDeck untuk memindahkannya, cubit untuk mengubah ukurannya, dan dorong ke luar tepi layar untuk menambatkannya sebagai tab FPS kecil. + Pada konsol genggam layar ganda, layar bawah dapat menampilkan unduhan, notifikasi, tangkapan layar, dan obrolan Steam. Tukar layar menempatkan gim di sana. + Tambahkan pustaka Steam dari kartu SD, drive USB, atau SSD, dan DroidDeck menyatukan semua gim di Pustaka kamu. + Toko memungkinkanmu masuk ke Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io, dan Game Jolt, lalu memasang dan memperbarui gim mereka dari DroidDeck. + Komponen seperti FEX, DXVK, dan VKD3D-Proton memperbarui diri sendiri, dan Proton Experimental ARM64 menjadi default, atau Proton 11.0 ARM64 setelah build tersebut terpasang. + Kompres Steam saat gim berjalan membebaskan RAM pada perangkat yang kekurangan memori. + Geser masuk dari tepi kanan untuk membuka menu sesi: mode touchpad, Keyboard PC, Mode latensi rendah, Profil gim, dan lainnya. + Gim berjalan lambat? Batasi frame rate di Akses cepat, lalu coba versi Proton lain atau preset FEX lain di komponen gim. + Audio gim pecah atau tidak ada? Coba opsi DirectAudio untuk gim di pengaturan Steam pada bagian Audio. + Penyiapan, lalu Penyimpanan, dapat membersihkan cache shader dan prefix sisa dari gim yang sudah kamu hapus. + Menemukan bug? Bagikan log di menu sesi mengumpulkan data diagnostik. Kirim ke #bug-reports di Discord. - Proses pertama menyiapkan desktop. Ini mungkin memerlukan beberapa menit. - Secara default, keluar dari aplikasi akan menjeda sesi; sesi dilanjutkan dari posisi terakhir saat Anda kembali. - Sentuhan berfungsi seperti touchpad: geser untuk menggerakkan penunjuk, ketuk untuk mengeklik. - Pengontrol Anda akan terlihat sebagai gamepad Xbox 360. Jika tidak, gunakan kontrol di layar. + Saat pertama kali dijalankan, desktop disiapkan. Ini mungkin memerlukan beberapa menit. + Sentuhan berfungsi sebagai touchpad: seret untuk menggerakkan penunjuk, ketuk untuk mengeklik. + Perilaku latar belakang menentukan apa yang terjadi saat kamu meninggalkan aplikasi: Manual menunggu Lanjutkan secara default, Otomatis menjeda, Tidak pernah membiarkannya tetap berjalan. + Geser masuk dari tepi kanan untuk membuka menu sesi, lalu pilih Keyboard PC untuk mengetik di aplikasi yang mengabaikan keyboard Android. + Keyboard PC di menu sesi memiliki ukuran, opasitas, dan grup tombol yang dapat diatur. + Kontrolermu terlihat sebagai pad Xbox 360. Jika tidak, gunakan kontrol di layar. + Menu sesi memiliki tombol mikrofon dan tombol Jeda sekarang untuk membekukan sesi sesuai permintaan. + Menemukan bug? Bagikan log di menu sesi mengumpulkan data diagnostik. Kirim ke #bug-reports di Discord. Sesi Ditampilkan saat sesi Steam atau desktop berjalan @@ -269,6 +289,10 @@ Touchpad Langsung Otomatis: touchpad di Desktop, langsung di Steam. + Pena + Mouse + Sentuhan + Tombol samping Kontrol di layar Steam + QAM Otomatis menampilkan kontrol saat tidak ada pengontrol yang terhubung. @@ -602,6 +626,8 @@ Nonaktif Default driver Kompres Steam saat gim berjalan + Kompres memori game yang tidak aktif + Mengompres memori game yang tidak aktif saat RAM rendah. Matikan jika game membeku beberapa detik kira-kira setiap setengah menit. Berlaku saat sesi dimulai berikutnya. 20 detik setelah gim dimulai, klien Steam dikompres ke zRAM agar gim mendapat lebih banyak memori, lalu dibaca kembali saat gim ditutup. Nonaktifkan jika sesi tertutup sesaat setelah gim dimulai. Batas RAM di atas tetap mengompres Steam saat sesi melampauinya. Batas RAM Berlaku saat klien Steam berjalan, di mode Steam atau dari desktop. Saat sesi menggunakan lebih dari ini, Steam lalu proses lain yang didukung dalam sesi dikompres ke zRAM. Batas lunak: tidak ada yang ditutup, tetapi gim dapat tersendat saat halaman dimuat kembali. @@ -612,7 +638,7 @@ Hanya Adreno. Lebih sedikit tersendat, lebih banyak penggunaan baterai dan panas. Perbaikan sesi Turnip: rendering sysmem - Lebih cepat untuk klien Steam; di gim, driver memilih rendering ubin atau memori sistem untuk setiap pass. Diperlukan pada Adreno 710/720/722. + Berlaku untuk klien Steam dan gim. Diperlukan pada Adreno 710/720/722. Lewati bantuan xalia milik Steam droiddeck-ntsync Pengganti userspace untuk driver ntsync Linux. Saat aktif, Proton menggunakannya sebagai pengganti droiddeck-esync dan droiddeck-fsync. Berfungsi dengan Proton Experimental ARM64, GE-Proton, dan proton-cachyos. Berlaku pada sesi berikutnya. @@ -1816,6 +1842,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Bersihkan Instal runtime terlebih dahulu Pustaka Steam tidak tersedia Pustaka SD sebelumnya tidak tersedia @@ -3808,8 +3835,6 @@ Alt+Tab, tombol Win, dan tombol Beranda tetap di sesi Berwarna abu-abu di Android? Info aplikasi → ⋮ → Izinkan setelan terbatas Diblokir oleh Android · Info aplikasi → ⋮ → Izinkan setelan terbatas - Tombol sistem DroidDeck - Menjaga Alt+Tab, tombol Win, dan tombol Beranda tetap di sesi DroidDeck yang aktif, bukan di Android. Aktifkan Kecerahan di Penyiapan → Integrasi Steam Jembatan Mali: mati %1$s tidak dapat menggunakan jembatan Mali (jembatan ini membutuhkan GPU Mali tanpa jalur driver sistem), sehingga sakelar ini tidak berpengaruh di sini. @@ -3969,10 +3994,11 @@ Atur ulang posisi Tampilkan label Tata letak ini tidak dapat diimpor + Diinstal melalui %1$s Salju Kirmizi Permukaan putih dengan aksen merah. - + Soundtrack Musik Opsi pemutaran diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index cbca952ea9..0936bff97b 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -9,15 +9,35 @@ DroidDeck non è riuscito a riavviarsi automaticamente. Chiudi completamente l\'app, poi riaprila. DroidDeck - Al primo avvio viene scaricato Steam. Potrebbero volerci alcuni minuti. - Per impostazione predefinita, uscire dall\'app mette in pausa Steam; al tuo ritorno riprende da dove si era interrotto. - Il tuo controller viene visto come un pad Xbox 360. In alternativa, usa i controlli su schermo. + Al primo avvio viene scaricato Steam. Potrebbe volerci qualche minuto. + Il tuo controller appare a Steam come un controller Steam Deck. Passa a un pad Steam Controller, DualShock 4, DualSense o Xbox 360 nelle impostazioni della sessione; si applica dalla sessione successiva. + Tieni premuto Indietro sul controller per aprire il menu Accesso rapido di Steam. Tieni premuto Indietro per le scorciatoie Steam deve essere attivo nelle impostazioni della sessione. + Comportamento in background decide cosa succede quando lasci l\'app: Nativo prepara Steam alla sospensione, Auto lo mette in pausa, Manuale attende Riprendi, Mai lo lascia in esecuzione. + I giochi Steam usano il Limite frame di Steam in Accesso rapido. Lo schermo passa a una frequenza di aggiornamento che il limite divide in modo esatto, se ce n\'è una. + Modalità bassa latenza nel menu della sessione invia l\'input del controller a 1000 Hz invece di 250 Hz, con un po\' più di CPU e batteria. + Ogni gioco ha il proprio profilo con Proton, FEX, componenti e impostazioni dell\'ambiente. + Il menu della sessione ha un interruttore del microfono per la chat vocale e un pulsante Sospendi ora per bloccare la sessione quando vuoi. + Trascina l\'HUD di DroidDeck per spostarlo, pizzica per ridimensionarlo e spingilo oltre un bordo per ancorarlo come piccola scheda FPS. + Sulle console portatili con doppio schermo, lo schermo inferiore può mostrare download, notifiche, screenshot e chat di Steam. Scambia schermi sposta lì il gioco. + Aggiungi librerie Steam da una scheda SD, un\'unità USB o un SSD, e DroidDeck tiene i giochi insieme nella tua Libreria. + Negozi ti permette di accedere a Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io e Game Jolt, poi di installare e aggiornare i loro giochi da DroidDeck. + I componenti come FEX, DXVK e VKD3D-Proton si aggiornano da soli, e Proton Experimental ARM64 è il predefinito, oppure Proton 11.0 ARM64 una volta installata quella build. + Comprimi Steam durante il gioco libera RAM sui dispositivi che ne hanno poca. + Scorri verso l\'interno dal bordo destro per aprire il menu della sessione: modalità touchpad, Tastiera PC, Modalità bassa latenza, Profilo del gioco e altro. + Il gioco è lento? Limita il frame rate in Accesso rapido, poi prova un\'altra versione di Proton o un altro preset FEX nei componenti del gioco. + Audio del gioco che gracchia o manca? Prova l\'opzione DirectAudio per i giochi nelle impostazioni di Steam, sotto Audio. + Configurazione, poi Archiviazione, può eliminare le cache degli shader e i prefix rimasti dei giochi rimossi. + Hai trovato un bug? Condividi log nel menu della sessione raccoglie la diagnostica. Pubblicala in #bug-reports su Discord. - Al primo avvio viene configurato il desktop. Potrebbero volerci alcuni minuti. - Per impostazione predefinita, uscire dall\'app mette in pausa la sessione; al tuo ritorno riprende da dove si era interrotta. - Il touchscreen funziona come un touchpad: trascina per spostare il puntatore, tocca per fare clic. - Il tuo controller viene visto come un pad Xbox 360. In alternativa, usa i controlli su schermo. + Al primo avvio viene configurato il desktop. Potrebbe volerci qualche minuto. + Il tocco funziona come un touchpad: trascina per muovere il puntatore, tocca per fare clic. + Comportamento in background decide cosa succede quando lasci l\'app: Manuale attende Riprendi per impostazione predefinita, Auto mette in pausa, Mai lascia in esecuzione. + Scorri verso l\'interno dal bordo destro per aprire il menu della sessione, poi scegli Tastiera PC per scrivere nelle app che ignorano la tastiera di Android. + La Tastiera PC nel menu della sessione ha dimensione, opacità e gruppi di tasti regolabili. + Il tuo controller appare come un pad Xbox 360. Altrimenti usa i comandi su schermo. + Il menu della sessione ha un interruttore del microfono e un pulsante Sospendi ora per bloccare la sessione quando vuoi. + Hai trovato un bug? Condividi log nel menu della sessione raccoglie la diagnostica. Pubblicala in #bug-reports su Discord. Sessione Visibile mentre è aperta una sessione Steam o desktop @@ -269,6 +289,10 @@ Touchpad Diretto Auto: touchpad sul Desktop, diretto in Steam. + Penna + Mouse + Tocco + Tasto laterale Controlli su schermo Steam + QAM Auto mostra i controlli quando non è collegato nessun controller. @@ -606,6 +630,8 @@ Disattivo Predefinito del driver Comprimi Steam durante il gioco + Comprimi la memoria inattiva del gioco + Comprime la memoria inattiva del gioco quando la RAM scarseggia. Disattivalo se i giochi si bloccano per qualche secondo circa ogni mezzo minuto. Si applica al prossimo avvio della sessione. 20 s dopo l\'avvio di un gioco, il client Steam viene compresso in zRAM per lasciare più memoria al gioco e viene riletto quando il gioco si chiude. Disattivalo se la sessione si chiude poco dopo l\'avvio dei giochi. Un limite di RAM impostato sopra comprime comunque Steam quando la sessione lo supera. Limite RAM Si applica mentre il client Steam è in esecuzione, in modalità Steam o dal desktop. Quando la sessione usa più di questo valore, Steam e poi gli altri processi supportati della sessione vengono compressi in zRAM. È un limite morbido: non viene chiuso nulla, ma i giochi possono scattare mentre le pagine vengono recuperate. @@ -616,7 +642,7 @@ Solo Adreno. Meno scatti, più consumo di batteria e più calore. Correzioni della sessione Turnip: rendering sysmem - Più veloce per il client di Steam; nei giochi il driver sceglie per ogni passata tra rendering a tile e in memoria di sistema. Necessario su Adreno 710/720/722. + Si applica al client Steam e ai giochi. Necessario su Adreno 710/720/722. Salta l\'assistente xalia di Steam droiddeck-ntsync Un sostituto in userspace del driver ntsync di Linux. Quando è attivo, Proton lo usa al posto di droiddeck-esync e droiddeck-fsync. Funziona con Proton Experimental ARM64, GE-Proton e proton-cachyos. Si applica dalla prossima sessione. @@ -1844,6 +1870,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Pulisci Installa prima il runtime La libreria di Steam non è disponibile La libreria SD precedente non è disponibile @@ -3875,8 +3902,6 @@ Alt+Tab, tasto Win e tasto Home restano nella sessione Disattivato in grigio su Android? Informazioni app → ⋮ → Consenti impostazioni con limitazioni Bloccato da Android · Informazioni app → ⋮ → Consenti impostazioni con limitazioni - Tasti di sistema DroidDeck - Mantiene Alt+Tab, il tasto Win e il tasto Home in una sessione DroidDeck attiva anziché in Android. Attiva Luminosità in Configurazione → Integrazione con Steam Ponte Mali: disattivato %1$s non può usare il bridge Mali (richiede una GPU Mali senza un percorso tramite driver di sistema), quindi questo interruttore non ha effetto qui. @@ -4038,10 +4063,11 @@ Ripristina posizioni Mostra etichetta Impossibile importare questo layout + Si installa tramite %1$s Neve scarlatta Superfici bianche con accenti rossi. - + Colonne sonore Musica Opzioni di riproduzione diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 93dda1d018..10434076eb 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -9,15 +9,35 @@ DroidDeck を自動的に再起動できませんでした。アプリを完全に終了してから、もう一度開いてください。 DroidDeck - 初回起動時はSteamをダウンロードします。数分かかる場合があります。 - デフォルトでは、アプリを離れるとSteamが一時停止し、戻ると前回の続きから再開します。 - コントローラーはXbox 360コントローラーとして認識されます。それ以外の場合は、画面コントローラーを使用してください。 + 初回起動時にSteamをダウンロードします。数分かかる場合があります。 + コントローラーはSteamにSteam Deckコントローラーとして認識されます。セッション設定でSteam Controller、DualShock 4、DualSense、Xbox 360パッドに切り替えられます。変更は次のセッションから反映されます。 + コントローラーの戻るを長押しすると、Steamのクイックアクセスメニューが開きます。セッション設定で「戻る長押しでSteamショートカット」をオンにしておく必要があります。 + バックグラウンド動作は、アプリを離れたときの挙動を決めます。ネイティブはSteamをスリープに備えさせ、自動は一時停止し、手動は「再開」を待ち、しないは実行し続けます。 + Steamのゲームは、クイックアクセスにあるSteamのフレームレート制限を使います。上限を均等に割り切れるリフレッシュレートがあれば、ディスプレイはそれに切り替わります。 + セッションメニューの低遅延モードは、コントローラー入力を250 Hzではなく1000 Hzで送信します。その分、CPUとバッテリーの消費が少し増えます。 + 各ゲームには、Proton、FEX、コンポーネント、環境設定を含む専用のプロファイルがあります。 + セッションメニューには、ボイスチャット用のマイク切り替えと、必要なときにセッションを凍結する「今すぐ一時停止」ボタンがあります。 + DroidDeckのHUDはドラッグで移動、ピンチでサイズ変更でき、画面の端へ押し出すと小さなFPSタブとしてドックされます。 + 2画面のハンドヘルドでは、下の画面にダウンロード、通知、スクリーンショット、Steamチャットを表示できます。「画面を入れ替え」を使うと、代わりにゲームをそこに表示します。 + SDカード、USBドライブ、SSDからSteamライブラリを追加でき、DroidDeckはゲームをライブラリにまとめて表示します。 + ストアでは、Epic Games、GOG、Xbox、EA、Battle.net、Ubisoft Connect、Amazon Games、itch.io、Game Joltにサインインして、DroidDeckからそれらのゲームをインストール・更新できます。 + FEX、DXVK、VKD3D-Protonなどのコンポーネントは自動で更新されます。既定はProton Experimental ARM64で、Proton 11.0 ARM64がインストールされている場合はそちらになります。 + ゲーム実行中はSteamを圧縮すると、メモリが少ない端末でRAMを確保できます。 + 画面の右端から内側にスワイプするとセッションメニューが開きます。タッチパッドモード、PCキーボード、低遅延モード、ゲームプロファイルなどがあります。 + ゲームが重い場合は、クイックアクセスでフレームレートを制限し、ゲームのコンポーネントで別のProtonバージョンやFEXプリセットを試してください。 + ゲームの音が割れる、または出ない場合は、Steam設定のオーディオにある「ゲームでDirectAudioを使用」を試してください。 + セットアップのストレージでは、シェーダーキャッシュや、削除したゲームの残ったプレフィックスを消去できます。 + 不具合に遭遇しましたか?セッションメニューの「ログを共有」で診断情報をまとめられます。Discordの#bug-reportsに投稿してください。 - 初回起動時はデスクトップをセットアップします。数分かかる場合があります。 - デフォルトでは、アプリを離れるとセッションが一時停止し、戻ると前回の続きから再開します。 - タッチはトラックパッドのように機能します。ドラッグでポインタを移動し、タップでクリックします。 - コントローラーはXbox 360コントローラーとして認識されます。それ以外の場合は、画面コントローラーを使用してください。 + 初回起動時にデスクトップをセットアップします。数分かかる場合があります。 + タッチはタッチパッドとして動作します。ドラッグでポインターを動かし、タップでクリックします。 + バックグラウンド動作は、アプリを離れたときの挙動を決めます。手動は既定で「再開」を待ち、自動は一時停止し、しないは実行し続けます。 + 画面の右端から内側にスワイプしてセッションメニューを開き、PCキーボードを選ぶと、Androidのキーボードを受け付けないアプリでも入力できます。 + セッションメニューのPCキーボードは、サイズ、不透明度、キーグループを調整できます。 + コントローラーはXbox 360パッドとして認識されます。そうでない場合は、画面上のコントロールを使ってください。 + セッションメニューには、マイク切り替えと、必要なときにセッションを凍結する「今すぐ一時停止」ボタンがあります。 + 不具合に遭遇しましたか?セッションメニューの「ログを共有」で診断情報をまとめられます。Discordの#bug-reportsに投稿してください。 セッション Steamまたはデスクトップのセッション中に表示 @@ -269,6 +289,10 @@ トラックパッド ダイレクト 自動:デスクトップではトラックパッド、Steamではダイレクトタッチを使用します。 + ペン + マウス + タッチ + サイドボタン 画面コントローラー Steam + QAM 自動では、コントローラーが接続されていないときに画面コントローラーを表示します。 @@ -602,6 +626,8 @@ オフ ドライバーのデフォルト ゲーム実行中はSteamを圧縮 + ゲームのアイドルメモリを圧縮 + RAMが少ないときにゲームのアイドルメモリを圧縮します。ゲームが30秒ごとに数秒止まる場合はオフにしてください。次回のセッション開始時に適用されます。 ゲーム開始の20秒後、SteamクライアントをzRAMに圧縮してゲームに使えるメモリを増やし、ゲーム終了時に読み戻します。ゲーム開始直後にセッションが終了する場合はオフにしてください。上のRAM上限を設定している場合は、セッションが上限を超えるとSteamは引き続き圧縮されます。 RAM上限 Steamモードでもデスクトップからでも、Steamクライアントの実行中に適用されます。セッションの使用量がこの値を超えると、Steam、次にセッション内の対応する他のプロセスがzRAMに圧縮されます。ソフトな上限のため何も終了されませんが、ページの読み戻し中にゲームがカクつくことがあります。 @@ -612,7 +638,7 @@ Adrenoのみ。スタッターは減りますが、消費電力と発熱が増えます。 セッション修正 Turnip:sysmemレンダリング - Steamクライアントが高速になります。ゲームではドライバーがパスごとにタイルレンダリングとシステムメモリレンダリングを選びます。Adreno 710/720/722では必須です。 + Steamクライアントとゲームに適用。Adreno 710/720/722では必須です。 Steamのxalia補助をスキップ droiddeck-ntsync Linuxのntsyncドライバーをユーザー空間で代替する機能です。オンの間、Protonはdroiddeck-esyncとdroiddeck-fsyncの代わりにこれを使用します。Proton Experimental ARM64、GE-Proton、proton-cachyosで動作します。次回のセッションで有効になります。 @@ -1816,6 +1842,7 @@ %1$s ✓ Ctrl+C Ctrl+D + クリア 先に実行環境をインストールしてください Steamライブラリを利用できません 以前のSDライブラリを利用できません @@ -3808,8 +3835,6 @@ Alt+Tab、Win キー、ホームボタンをセッション内で使えます Androidでグレー表示されていますか?アプリ情報 → ⋮ → 制限付き設定を許可 Androidによってブロックされています · アプリ情報 → ⋮ → 制限付き設定を許可 - DroidDeck システムキー - Alt+Tab、Win キー、ホームボタンを Android ではなく操作中の DroidDeck セッションで使えるようにします。 「セットアップ」→「Steam連携」で明るさをオンにしてください Mali ブリッジ: オフ %1$s では Mali ブリッジを使用できません(システムドライバーの経路が存在しない Mali GPU が必要です)。そのため、このスイッチはここでは効果がありません。 @@ -3969,10 +3994,11 @@ 位置をリセット ラベルを表示 このレイアウトをインポートできませんでした + %1$s からインストールします 緋色の雪 白いサーフェスに赤のアクセント。 - + サウンドトラック 音楽 再生オプション diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 048dced14f..4beb86b515 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -9,15 +9,35 @@ DroidDeck을 자동으로 다시 시작하지 못했습니다. 앱을 완전히 종료한 후 다시 여세요. DroidDeck - 첫 실행 시 Steam을 다운로드합니다. 몇 분 정도 걸릴 수 있습니다. - 기본적으로 앱을 나가면 Steam이 일시 중지되며, 다시 돌아오면 중단된 부분부터 재개됩니다. - 컨트롤러는 Xbox 360 컨트롤러로 인식됩니다. 컨트롤러가 없으면 화면 컨트롤을 사용하세요. + 처음 실행하면 Steam을 다운로드합니다. 몇 분 걸릴 수 있습니다. + 컨트롤러는 Steam에 Steam Deck 컨트롤러로 표시됩니다. 세션 설정에서 Steam Controller, DualShock 4, DualSense 또는 Xbox 360 패드로 바꿀 수 있으며, 다음 세션부터 적용됩니다. + 컨트롤러의 뒤로를 길게 누르면 Steam의 빠른 액세스 메뉴가 열립니다. 세션 설정에서 뒤로 길게 눌러 Steam 단축키가 켜져 있어야 합니다. + 백그라운드 동작은 앱을 벗어났을 때 어떻게 할지 정합니다. 네이티브는 Steam을 절전에 대비시키고, 자동은 일시 중지하고, 수동은 재개를 기다리며, 안 함은 계속 실행합니다. + Steam 게임은 빠른 액세스의 Steam 프레임 제한을 사용합니다. 제한값으로 나누어떨어지는 주사율이 있으면 디스플레이가 그 주사율로 전환됩니다. + 세션 메뉴의 저지연 모드는 컨트롤러 입력을 250 Hz 대신 1000 Hz로 보내며, CPU와 배터리를 조금 더 사용합니다. + 각 게임에는 Proton, FEX, 구성 요소, 환경 설정이 포함된 자체 프로필이 있습니다. + 세션 메뉴에는 음성 채팅용 마이크 토글과 필요할 때 세션을 정지시키는 지금 일시 중지 버튼이 있습니다. + DroidDeck HUD는 드래그해서 옮기고, 핀치해서 크기를 바꾸고, 화면 가장자리 밖으로 밀면 작은 FPS 탭으로 고정됩니다. + 듀얼 스크린 휴대용 기기에서는 아래쪽 화면에 다운로드, 알림, 스크린샷, Steam 채팅을 표시할 수 있습니다. 화면 바꾸기를 누르면 게임이 그쪽으로 옮겨집니다. + SD 카드, USB 드라이브, SSD에서 Steam 라이브러리를 추가할 수 있으며, DroidDeck이 게임을 라이브러리에 함께 모아 줍니다. + 스토어에서는 Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io, Game Jolt에 로그인하고 DroidDeck에서 해당 게임을 설치하고 업데이트할 수 있습니다. + FEX, DXVK, VKD3D-Proton 같은 구성 요소는 스스로 업데이트되며, 기본값은 Proton Experimental ARM64이고 Proton 11.0 ARM64 빌드가 설치되면 그쪽이 기본값이 됩니다. + 게임 실행 중 Steam 압축은 메모리가 부족한 기기에서 RAM을 확보해 줍니다. + 오른쪽 가장자리에서 안쪽으로 스와이프하면 세션 메뉴가 열립니다. 터치패드 모드, PC 키보드, 저지연 모드, 게임 프로필 등이 있습니다. + 게임이 느린가요? 빠른 액세스에서 프레임 레이트를 제한한 다음, 게임의 구성 요소에서 다른 Proton 버전이나 FEX 프리셋을 시도해 보세요. + 게임 소리가 지직거리거나 나오지 않나요? Steam 설정의 오디오에서 게임에서 DirectAudio 사용 토글을 시도해 보세요. + 설정의 저장 공간에서 셰이더 캐시와 삭제한 게임에 남은 프리픽스를 정리할 수 있습니다. + 버그를 만났나요? 세션 메뉴의 로그 공유가 진단 정보를 묶어 줍니다. Discord의 #bug-reports에 올려 주세요. - 첫 실행 시 데스크톱을 설정합니다. 몇 분 정도 걸릴 수 있습니다. - 기본적으로 앱을 나가면 세션이 일시 중지되며, 다시 돌아오면 중단된 부분부터 재개됩니다. - 터치는 트랙패드처럼 작동합니다. 드래그하여 포인터를 이동하고, 탭하여 클릭합니다. - 컨트롤러는 Xbox 360 컨트롤러로 인식됩니다. 컨트롤러가 없으면 화면 컨트롤을 사용하세요. + 처음 실행하면 데스크톱을 설정합니다. 몇 분 걸릴 수 있습니다. + 터치는 터치패드처럼 동작합니다. 드래그하면 포인터가 움직이고, 탭하면 클릭합니다. + 백그라운드 동작은 앱을 벗어났을 때 어떻게 할지 정합니다. 수동은 기본적으로 재개를 기다리고, 자동은 일시 중지하며, 안 함은 계속 실행합니다. + 오른쪽 가장자리에서 안쪽으로 스와이프해 세션 메뉴를 연 다음 PC 키보드를 선택하면, Android 키보드를 무시하는 앱에서도 입력할 수 있습니다. + 세션 메뉴의 PC 키보드는 크기, 불투명도, 키 그룹을 조절할 수 있습니다. + 컨트롤러는 Xbox 360 패드로 표시됩니다. 그렇지 않으면 화면 컨트롤을 사용하세요. + 세션 메뉴에는 마이크 토글과 필요할 때 세션을 정지시키는 지금 일시 중지 버튼이 있습니다. + 버그를 만났나요? 세션 메뉴의 로그 공유가 진단 정보를 묶어 줍니다. Discord의 #bug-reports에 올려 주세요. 세션 Steam 또는 데스크톱 세션이 실행 중일 때 표시 @@ -269,6 +289,10 @@ 터치패드 직접 터치 자동: 데스크톱에서는 터치패드, Steam에서는 직접 터치를 사용합니다. + 펜 + 마우스 + 터치 + 측면 버튼 화면 컨트롤 Steam + QAM 자동 모드에서는 컨트롤러가 연결되지 않은 경우 화면 컨트롤을 표시합니다. @@ -602,6 +626,8 @@ 끄기 드라이버 기본값 게임 실행 중 Steam 압축 + 유휴 게임 메모리 압축 + RAM이 부족할 때 유휴 게임 메모리를 압축합니다. 게임이 약 30초마다 몇 초씩 멈추면 끄세요. 다음 세션을 시작할 때 적용됩니다. 게임이 시작되고 20초 후 Steam 클라이언트를 zRAM으로 압축해 게임에 더 많은 메모리를 남기고, 게임이 종료되면 다시 읽어 들입니다. 게임 시작 직후 세션이 종료되면 이 옵션을 끄세요. 위의 RAM 제한을 설정하면 세션이 이를 초과할 때 여전히 Steam을 압축합니다. RAM 제한 Steam 모드나 데스크톱에서 Steam 클라이언트가 실행되는 동안 적용됩니다. 세션이 이 값보다 많이 사용하면 Steam과 세션의 다른 지원 프로세스를 차례로 zRAM으로 압축합니다. 소프트 제한이므로 종료되는 것은 없지만, 페이지를 다시 읽어 들이는 동안 게임이 끊길 수 있습니다. @@ -612,7 +638,7 @@ Adreno에만 해당됩니다. 끊김이 줄어들지만 전력 소모와 발열이 증가합니다. 세션 수정 Turnip: sysmem 렌더링 - Steam 클라이언트가 빨라집니다. 게임에서는 드라이버가 패스마다 타일 렌더링과 시스템 메모리 렌더링 중 하나를 고릅니다. Adreno 710/720/722에 필수입니다. + Steam 클라이언트와 게임에 적용됩니다. Adreno 710/720/722에 필수입니다. Steam의 xalia 도우미 건너뛰기 droiddeck-ntsync Linux ntsync 드라이버를 사용자 공간에서 대신하는 기능입니다. 켜져 있으면 Proton이 droiddeck-esync와 droiddeck-fsync 대신 이 기능을 사용합니다. Proton Experimental ARM64, GE-Proton 및 proton-cachyos에서 작동합니다. 다음 세션에 적용됩니다. @@ -1816,6 +1842,7 @@ %1$s ✓ Ctrl+C Ctrl+D + 지우기 먼저 런타임을 설치하세요 Steam 라이브러리를 사용할 수 없습니다 이전 SD 라이브러리를 사용할 수 없습니다 @@ -3808,8 +3835,6 @@ Alt+Tab, Win 키, 홈 버튼이 세션 안에서 작동합니다 Android에서 회색으로 표시되나요? 앱 정보 → ⋮ → 제한된 설정 허용 Android에서 차단됨 · 앱 정보 → ⋮ → 제한된 설정 허용 - DroidDeck 시스템 키 - Alt+Tab, Win 키, 홈 버튼을 Android 대신 사용 중인 DroidDeck 세션에서 작동하게 합니다. 설정 → Steam 연동에서 밝기를 켜세요 Mali 브리지: 끔 Mali 브리지에는 시스템 드라이버 경로가 없는 Mali GPU가 필요하므로 %1$s에서는 사용할 수 없으며, 이 스위치는 여기서 아무 효과가 없습니다. @@ -3969,10 +3994,11 @@ 위치 초기화 라벨 표시 이 레이아웃을 가져올 수 없습니다 + %1$s을(를) 통해 설치합니다 진홍빛 눈 빨간색 포인트가 있는 흰색 표면. - + 사운드트랙 음악 재생 옵션 diff --git a/app/src/main/res/values-ms/strings.xml b/app/src/main/res/values-ms/strings.xml index 7d0a634ed9..d202e18bc5 100644 --- a/app/src/main/res/values-ms/strings.xml +++ b/app/src/main/res/values-ms/strings.xml @@ -9,15 +9,35 @@ DroidDeck tidak dapat dimulakan semula secara automatik. Tutup apl sepenuhnya, kemudian buka semula. DroidDeck - Larian pertama memuat turun Steam. Ini mungkin mengambil beberapa minit. - Secara lalai, meninggalkan apl ini menjedakan Steam; ia menyambung semula dari tempat ia berhenti apabila anda kembali. - Pengawal anda akan muncul sebagai pad Xbox 360. Jika tidak, gunakan kawalan pada skrin. + Larian pertama memuat turun Steam. Ini mungkin mengambil masa beberapa minit. + Pengawal anda dipaparkan kepada Steam sebagai pengawal Steam Deck. Tukarkannya kepada pad Steam Controller, DualShock 4, DualSense atau Xbox 360 dalam tetapan sesi; ia berkuat kuasa pada sesi seterusnya. + Tahan Kembali pada pengawal anda untuk membuka menu Akses pantas Steam. Tahan Kembali untuk pintasan Steam mesti dihidupkan dalam tetapan sesi. + Gelagat latar belakang menentukan apa yang berlaku apabila anda meninggalkan apl: Asli menyediakan Steam untuk tidur, Auto menjedanya, Manual menunggu Sambung, Tidak pernah membiarkannya terus berjalan. + Permainan Steam menggunakan Had bingkai Steam dalam Akses pantas. Paparan bertukar kepada kadar segar semula yang boleh dibahagi sama rata oleh had itu apabila ada. + Mod kependaman rendah dalam menu sesi menghantar input pengawal pada 1000 Hz dan bukannya 250 Hz, dengan sedikit lebih CPU dan bateri. + Setiap permainan mempunyai profilnya sendiri dengan Proton, FEX, komponen dan tetapan persekitaran. + Menu sesi mempunyai togol mikrofon untuk sembang suara dan butang Gantung sekarang untuk membekukan sesi apabila diperlukan. + Seret HUD DroidDeck untuk menggerakkannya, cubit untuk mengubah saiznya, dan tolak ke tepi untuk memautkannya sebagai tab FPS kecil. + Pada konsol pegang tangan dwiskrin, skrin bawah boleh menunjukkan muat turun, pemberitahuan, tangkapan skrin dan sembang Steam. Tukar skrin meletakkan permainan di bawah sana. + Tambah pustaka Steam daripada kad SD, pemacu USB atau SSD, dan DroidDeck menyatukan permainan dalam Pustaka anda. + Kedai membolehkan anda log masuk ke Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io dan Game Jolt, kemudian memasang dan mengemas kini permainan mereka daripada DroidDeck. + Komponen seperti FEX, DXVK dan VKD3D-Proton mengemas kini sendiri, dan Proton Experimental ARM64 ialah lalai, atau Proton 11.0 ARM64 sebaik sahaja binaan itu dipasang. + Mampatkan Steam semasa permainan berjalan membebaskan RAM pada peranti yang kekurangan memori. + Leret masuk dari tepi kanan untuk membuka menu sesi: mod pad sentuh, Papan kekunci PC, Mod kependaman rendah, profil permainan dan banyak lagi. + Permainan berjalan perlahan? Hadkan kadar bingkai dalam Akses pantas, kemudian cuba versi Proton atau pratetap FEX lain dalam komponen permainan. + Bunyi permainan berderak atau tiada? Cuba togol DirectAudio untuk permainan dalam tetapan Steam di bawah Audio. + Persediaan, kemudian Storan, boleh mengosongkan cache shader dan prefix yang tertinggal daripada permainan yang anda buang. + Menemui pepijat? Kongsi log dalam menu sesi menghimpunkan diagnostik. Siarkan dalam #bug-reports di Discord. - Larian pertama menyediakan desktop. Ini mungkin mengambil beberapa minit. - Secara lalai, meninggalkan apl ini menjedakan sesi; ia menyambung semula dari tempat ia berhenti apabila anda kembali. - Sentuhan berfungsi sebagai pad sentuh: seret untuk menggerakkan penunjuk, ketik untuk klik. - Pengawal anda akan muncul sebagai pad Xbox 360. Jika tidak, gunakan kawalan pada skrin. + Larian pertama menyediakan desktop. Ini mungkin mengambil masa beberapa minit. + Sentuhan berfungsi sebagai pad sentuh: seret untuk menggerakkan penuding, ketik untuk klik. + Gelagat latar belakang menentukan apa yang berlaku apabila anda meninggalkan apl: Manual menunggu Sambung secara lalai, Auto menjeda, Tidak pernah membiarkannya terus berjalan. + Leret masuk dari tepi kanan untuk membuka menu sesi, kemudian pilih Papan kekunci PC untuk menaip dalam apl yang mengabaikan papan kekunci Android. + Papan kekunci PC dalam menu sesi mempunyai saiz, kelegapan dan kumpulan kekunci yang boleh dilaraskan. + Pengawal anda dipaparkan sebagai pad Xbox 360. Jika tidak, gunakan kawalan atas skrin. + Menu sesi mempunyai togol mikrofon dan butang Gantung sekarang untuk membekukan sesi apabila diperlukan. + Menemui pepijat? Kongsi log dalam menu sesi menghimpunkan diagnostik. Siarkan dalam #bug-reports di Discord. Sesi Dipaparkan semasa sesi Steam atau desktop sedang dibuka @@ -269,6 +289,10 @@ Pad sentuh Terus Auto: pad sentuh pada Desktop, terus dalam Steam. + Pen + Tetikus + Sentuhan + Butang sisi Kawalan pada skrin Steam + QAM Auto memaparkan kawalan apabila tiada pengawal disambungkan. @@ -602,6 +626,8 @@ Mati Lalai pemacu Mampatkan Steam semasa permainan berjalan + Mampatkan memori permainan terbiar + Mampatkan memori permainan terbiar apabila RAM rendah. Matikan jika permainan membeku beberapa saat lebih kurang setiap setengah minit. Berkuat kuasa apabila sesi dimulakan seterusnya. 20 s selepas permainan bermula, klien Steam dimampatkan ke dalam zRAM untuk memberi permainan lebih banyak memori, dan dibaca semula apabila permainan ditutup. Matikan ini jika sesi tertutup sejurus selepas permainan bermula. Had RAM di atas masih memampatkan Steam apabila sesi melebihinya. Had RAM Berkuat kuasa semasa klien Steam berjalan, dalam mod Steam atau dari desktop. Apabila sesi menggunakan lebih daripada ini, Steam dan kemudian proses lain sesi yang disokong dimampatkan ke dalam zRAM. Had lembut: tiada apa yang ditutup, tetapi permainan mungkin tersekat-sekat semasa halaman dibaca semula. @@ -612,7 +638,7 @@ Adreno sahaja. Kurang tersekat-sekat, lebih penggunaan bateri dan haba. Pembetulan sesi Turnip: rendering sysmem - Lebih pantas untuk klien Steam; dalam permainan, pemacu memilih pemaparan jubin atau memori sistem bagi setiap laluan. Diperlukan pada Adreno 710/720/722. + Terpakai pada klien Steam dan permainan. Diperlukan pada Adreno 710/720/722. Langkau pembantu xalia Steam droiddeck-ntsync Pengganti ruang pengguna untuk pemacu ntsync Linux. Semasa ia hidup, Proton menggunakannya sebagai ganti droiddeck-esync dan droiddeck-fsync. Berfungsi dengan Proton Experimental ARM64, GE-Proton dan proton-cachyos. Berkuat kuasa pada sesi seterusnya. @@ -1816,6 +1842,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Kosongkan Pasang masa jalan dahulu Pustaka Steam tidak tersedia Pustaka SD terdahulu tidak tersedia @@ -3808,8 +3835,6 @@ Alt+Tab, kekunci Win dan butang Utama kekal dalam sesi Dikelabukan dalam Android? Maklumat apl → ⋮ → Benarkan tetapan terhad Disekat oleh Android · Maklumat apl → ⋮ → Benarkan tetapan terhad - Kekunci sistem DroidDeck - Mengekalkan Alt+Tab, kekunci Win dan butang Utama dalam sesi DroidDeck yang aktif, bukan Android. Hidupkan Kecerahan dalam Persediaan → Integrasi Steam Jambatan Mali: mati %1$s tidak boleh menggunakan jambatan Mali (jambatan itu memerlukan GPU Mali tanpa laluan pemandu sistem), jadi suis ini tidak memberi kesan di sini. @@ -3969,10 +3994,11 @@ Tetapkan semula kedudukan Tunjukkan label Susun atur ini tidak dapat diimport + Dipasang melalui %1$s Salji Merah Skarlet Permukaan putih dengan aksen merah. - + Runut bunyi Muzik Pilihan main balik diff --git a/app/src/main/res/values-nb/strings.xml b/app/src/main/res/values-nb/strings.xml index 43678cb4ad..c427fbc686 100644 --- a/app/src/main/res/values-nb/strings.xml +++ b/app/src/main/res/values-nb/strings.xml @@ -9,15 +9,35 @@ DroidDeck kunne ikke starte på nytt automatisk. Lukk appen helt, og åpne den igjen. DroidDeck - Første gang lastes Steam ned. Dette kan ta noen minutter. - Som standard settes Steam på pause når du lukker appen, og fortsetter der du slapp når du kommer tilbake. - Kontrolleren din vises som en Xbox 360-kontroller. Hvis ikke, bruk skjermkontrollene. + Første oppstart laster ned Steam. Det kan ta noen minutter. + Kontrolleren din vises for Steam som en Steam Deck-kontroller. Bytt til en Steam Controller, DualShock 4, DualSense eller Xbox 360-kontroller i øktinnstillingene; det gjelder fra neste økt. + Hold Tilbake på kontrolleren for å åpne Steams Hurtigmeny. Hold Tilbake for Steam-snarveier må være slått på i øktinnstillingene. + Bakgrunnsoppførsel bestemmer hva som skjer når du forlater appen: Nativ gjør Steam klar for hvilemodus, Auto setter det på pause, Manuell venter på Gjenoppta, Aldri lar det kjøre. + Steam-spill bruker Steams Bildefrekvensgrense i Hurtigmeny. Skjermen bytter til en oppdateringsfrekvens som grensen går opp i, når det finnes en. + Modus for lav forsinkelse i øktmenyen sender kontrollerinndata med 1000 Hz i stedet for 250 Hz, mot litt mer CPU og batteribruk. + Hvert spill har sin egen profil med Proton, FEX, komponenter og miljøinnstillinger. + Øktmenyen har en mikrofonbryter for talechat og en Sett på pause nå-knapp for å fryse økten ved behov. + Dra DroidDeck-HUDen for å flytte den, knip for å endre størrelsen, og skyv den ut mot en kant for å feste den som en liten FPS-fane. + På håndholdte enheter med to skjermer kan den nederste skjermen vise nedlastinger, varsler, skjermbilder og Steam-chat. Bytt skjermer legger spillet nederst i stedet. + Legg til Steam-biblioteker fra et SD-kort, en USB-stasjon eller en SSD, så holder DroidDeck spillene samlet i Biblioteket ditt. + Butikker lar deg logge inn på Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io og Game Jolt, og deretter installere og oppdatere spillene deres fra DroidDeck. + Komponenter som FEX, DXVK og VKD3D-Proton oppdaterer seg selv, og Proton Experimental ARM64 er standard, eller Proton 11.0 ARM64 når den versjonen er installert. + Komprimer Steam mens et spill kjører frigjør minne på enheter som har lite. + Sveip inn fra høyre kant for å åpne øktmenyen: styreflatemodus, PC-tastatur, modus for lav forsinkelse, spillprofil og mer. + Kjører spillet tregt? Begrens bildefrekvensen i Hurtigmeny, og prøv deretter en annen Proton-versjon eller FEX-forhåndsinnstilling i spillets komponenter. + Knitrende eller manglende spillyd? Prøv bryteren DirectAudio for spill i Steam-innstillingene under Lyd. + Oppsett og deretter Lagring kan tømme shader-hurtigbuffere og gjenværende prefikser fra spill du har fjernet. + Har du funnet en feil? Del logger i øktmenyen samler diagnostikk. Legg dem ut i #bug-reports på Discord. - Første gang settes skrivebordet opp. Dette kan ta noen minutter. - Som standard settes sesjonen på pause når du lukker appen, og fortsetter der du slapp når du kommer tilbake. - Berøring fungerer som styreflate: dra for å flytte pekeren, trykk for å klikke. - Kontrolleren din vises som en Xbox 360-kontroller. Hvis ikke, bruk skjermkontrollene. + Første oppstart setter opp skrivebordet. Det kan ta noen minutter. + Berøring fungerer som en styreflate: dra for å flytte pekeren, trykk for å klikke. + Bakgrunnsoppførsel bestemmer hva som skjer når du forlater appen: Manuell venter på Gjenoppta som standard, Auto setter på pause, Aldri lar det kjøre. + Sveip inn fra høyre kant for å åpne øktmenyen, og velg deretter PC-tastatur for å skrive i apper som ignorerer Android-tastaturet. + PC-tastaturet i øktmenyen har justerbar størrelse, gjennomsiktighet og tastegrupper. + Kontrolleren din vises som en Xbox 360-kontroller. Ellers kan du bruke kontrollene på skjermen. + Øktmenyen har en mikrofonbryter og en Sett på pause nå-knapp for å fryse økten ved behov. + Har du funnet en feil? Del logger i øktmenyen samler diagnostikk. Legg dem ut i #bug-reports på Discord. Sesjon Vises mens en Steam- eller skrivebordssesjon er åpen @@ -269,6 +289,10 @@ Styreflate Direkte Auto: styreflate på Skrivebord, direkte i Steam. + Penn + Mus + Berøring + Sideknapp Skjermkontroller Steam + QAM Auto viser kontrollene når ingen kontroller er tilkoblet. @@ -604,6 +628,8 @@ Av Driverstandard Komprimer Steam mens et spill kjører + Komprimer inaktivt spillminne + Komprimerer inaktivt spillminne når RAM er lav. Slå av hvis spill fryser i noen sekunder omtrent hvert halve minutt. Trer i kraft neste gang økten starter. 20 s etter at et spill starter, komprimeres Steam-klienten til zRAM for å gi spillet mer minne, og leses inn igjen når spillet lukkes. Slå av hvis sesjonen lukkes kort tid etter at spill starter. En RAM-grense ovenfor komprimerer fortsatt Steam når sesjonen går over den. RAM-grense Gjelder mens Steam-klienten kjører, i Steam-modus eller fra skrivebordet. Når sesjonen bruker mer enn dette, komprimeres Steam og deretter sesjonens andre støttede prosesser til zRAM. En myk grense: ingenting lukkes, men spill kan hakke mens sider hentes tilbake. @@ -614,7 +640,7 @@ Bare Adreno. Færre hikk, mer batteribruk og varme. Sesjonsfikser Turnip: sysmem-rendering - Raskere for Steam-klienten; i spill velger driveren flis- eller systemminnerendering for hvert pass. Påkrevd på Adreno 710/720/722. + Gjelder Steam-klienten og spill. Påkrevd på Adreno 710/720/722. Hopp over Steams xalia-hjelper droiddeck-ntsync En erstatning i brukerrom for Linux-driveren ntsync. Mens dette er på, bruker Proton den i stedet for droiddeck-esync og droiddeck-fsync. Fungerer med Proton Experimental ARM64, GE-Proton og proton-cachyos. Gjelder fra neste sesjon. @@ -1834,6 +1860,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Tøm Installer kjøretiden først Steam-biblioteket er ikke tilgjengelig Det forrige SD-biblioteket er ikke tilgjengelig @@ -3837,8 +3864,6 @@ Alt+Tab, Win-tasten og Hjem-knappen blir i økten Nedtonet i Android? Appinfo → ⋮ → Tillat begrensede innstillinger Blokkert av Android · Appinfo → ⋮ → Tillat begrensede innstillinger - DroidDeck-systemtaster - Holder Alt+Tab, Win-tasten og Hjem-knappen i en aktiv DroidDeck-økt i stedet for Android. Slå på Lysstyrke i Oppsett → Steam-integrering Mali-bro: av %1$s kan ikke bruke Mali-broen (den krever en Mali-GPU uten en rute via systemdriveren), så denne bryteren har ingen effekt her. @@ -3999,10 +4024,11 @@ Tilbakestill plasseringer Vis etikett Kunne ikke importere dette oppsettet + Installeres via %1$s Skarlagenssnø Hvite flater med røde aksenter. - + Lydspor Musikk Avspillingsalternativer diff --git a/app/src/main/res/values-nl/strings.xml b/app/src/main/res/values-nl/strings.xml index 5247d1fedd..b559370fab 100644 --- a/app/src/main/res/values-nl/strings.xml +++ b/app/src/main/res/values-nl/strings.xml @@ -9,15 +9,35 @@ DroidDeck kon niet automatisch opnieuw starten. Sluit de app volledig af en open hem daarna opnieuw. DroidDeck - Bij de eerste start wordt Steam gedownload. Dit kan een paar minuten duren. - Standaard wordt Steam gepauzeerd als je de app verlaat; als je terugkomt, gaat het verder waar je was. - Je controller wordt gezien als Xbox 360-controller. Gebruik anders de schermbediening. + De eerste keer wordt Steam gedownload. Dat kan een paar minuten duren. + Je controller wordt aan Steam getoond als een Steam Deck-controller. Schakel in de sessie-instellingen over op een Steam Controller, DualShock 4, DualSense of Xbox 360-pad; dit geldt vanaf de volgende sessie. + Houd Terug ingedrukt op je controller om het Snelmenu van Steam te openen. Terug ingedrukt houden voor Steam-sneltoetsen moet aanstaan in de sessie-instellingen. + Gedrag op de achtergrond bepaalt wat er gebeurt als je de app verlaat: Systeemeigen maakt Steam klaar voor slaapstand, Automatisch pauzeert het, Handmatig wacht op Hervatten, Nooit laat het doorlopen. + Steam-games gebruiken de Framelimiet van Steam in het Snelmenu. Het scherm schakelt naar een verversingssnelheid waar de limiet gelijk op deelt, als die er is. + Modus voor lage latentie in het sessiemenu stuurt controllerinvoer met 1000 Hz in plaats van 250 Hz, voor iets meer CPU en batterij. + Elke game heeft een eigen profiel met Proton, FEX, componenten en omgevingsinstellingen. + Het sessiemenu heeft een microfoonschakelaar voor voicechat en een knop Nu onderbreken om de sessie op verzoek te bevriezen. + Sleep de DroidDeck-HUD om hem te verplaatsen, knijp om het formaat te wijzigen en duw hem tegen een rand om hem als klein FPS-tabblad vast te zetten. + Op handhelds met twee schermen kan het onderste scherm downloads, meldingen, screenshots en Steam-chat tonen. Met Schermen wisselen komt de game daar te staan. + Voeg Steam-bibliotheken toe vanaf een SD-kaart, USB-stick of SSD, en DroidDeck houdt de games bij elkaar in je Bibliotheek. + Met Winkels log je in bij Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io en Game Jolt, en installeer en update je hun games vanuit DroidDeck. + Componenten zoals FEX, DXVK en VKD3D-Proton updaten zichzelf, en Proton Experimental ARM64 is de standaard, of Proton 11.0 ARM64 zodra die build is geïnstalleerd. + Steam comprimeren terwijl een game draait maakt RAM vrij op apparaten die weinig geheugen hebben. + Veeg vanaf de rechterrand naar binnen om het sessiemenu te openen: touchpadmodus, Pc-toetsenbord, modus voor lage latentie, gameprofiel en meer. + Draait een game traag? Begrens de framerate in het Snelmenu en probeer dan een andere Proton-versie of FEX-preset in de componenten van de game. + Kraakt de audio of ontbreekt het geluid? Probeer de schakelaar DirectAudio voor games in de Steam-instellingen onder Audio. + Installatie, en dan Opslag, kan shadercaches en overgebleven prefixes van verwijderde games wissen. + Een bug gevonden? Logs delen in het sessiemenu bundelt diagnostiek. Plaats die in #bug-reports op Discord. - Bij de eerste start wordt de desktop ingericht. Dit kan een paar minuten duren. - Standaard wordt de sessie gepauzeerd als je de app verlaat; als je terugkomt, gaat die verder waar je was. - Aanraken werkt als touchpad: sleep om de aanwijzer te verplaatsen, tik om te klikken. - Je controller wordt gezien als Xbox 360-controller. Gebruik anders de schermbediening. + De eerste keer wordt de desktop ingesteld. Dat kan een paar minuten duren. + Aanraking werkt als touchpad: sleep om de aanwijzer te verplaatsen, tik om te klikken. + Gedrag op de achtergrond bepaalt wat er gebeurt als je de app verlaat: Handmatig wacht standaard op Hervatten, Automatisch pauzeert, Nooit laat het doorlopen. + Veeg vanaf de rechterrand naar binnen om het sessiemenu te openen en kies dan Pc-toetsenbord om te typen in apps die het Android-toetsenbord negeren. + Het Pc-toetsenbord in het sessiemenu heeft instelbare grootte, dekking en toetsgroepen. + Je controller wordt weergegeven als een Xbox 360-pad. Gebruik anders de bediening op het scherm. + Het sessiemenu heeft een microfoonschakelaar en een knop Nu onderbreken om de sessie op verzoek te bevriezen. + Een bug gevonden? Logs delen in het sessiemenu bundelt diagnostiek. Plaats die in #bug-reports op Discord. Sessie Wordt getoond zolang er een Steam- of desktopsessie open is @@ -269,6 +289,10 @@ Touchpad Direct Automatisch: touchpad op Desktop, direct in Steam. + Pen + Muis + Aanraken + Zijknop Schermbediening Steam + QAM Automatisch toont de bediening als er geen controller is verbonden. @@ -604,6 +628,8 @@ Uit Driverstandaard Steam comprimeren terwijl een game draait + Inactief gamegeheugen comprimeren + Comprimeert inactief gamegeheugen bij weinig RAM. Zet dit uit als games ongeveer elke halve minuut een paar seconden vastlopen. Geldt vanaf de volgende keer dat de sessie start. 20 s nadat een game start, wordt de Steam-client in zRAM gecomprimeerd om de game meer geheugen te geven, en teruggelezen als de game sluit. Zet dit uit als de sessie kort na het starten van games sluit. Een RAM-limiet hierboven comprimeert Steam nog steeds als de sessie die overschrijdt. RAM-limiet Geldt terwijl de Steam-client draait, in de Steam-modus of vanaf de desktop. Als de sessie meer gebruikt dan dit, worden Steam en daarna de andere ondersteunde processen van de sessie in zRAM gecomprimeerd. Een zachte limiet: er wordt niets gesloten, maar games kunnen haperen terwijl pagina’s terugkomen. @@ -614,7 +640,7 @@ Alleen Adreno. Minder haperingen, meer batterijverbruik en warmte. Sessiefixes Turnip: sysmem-rendering - Sneller voor de Steam-client; in games kiest het stuurprogramma per pass tussen tegel- en systeemgeheugenrendering. Vereist op Adreno 710/720/722. + Geldt voor de Steam-client en games. Vereist op Adreno 710/720/722. Sla de xalia-helper van Steam over droiddeck-ntsync Een userspace-vervanger voor de ntsync-driver van Linux. Terwijl dit aan staat, gebruikt Proton dit in plaats van droiddeck-esync en droiddeck-fsync. Werkt met Proton Experimental ARM64, GE-Proton en proton-cachyos. Geldt vanaf de volgende sessie. @@ -1834,6 +1860,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Wissen Installeer eerst de runtime Steam-bibliotheek is niet beschikbaar Vorige SD-bibliotheek is niet beschikbaar @@ -3837,8 +3864,6 @@ Alt+Tab, Win-toets en Home-knop blijven in de sessie Grijs in Android? App-info → ⋮ → Beperkte instellingen toestaan Geblokkeerd door Android · App-info → ⋮ → Beperkte instellingen toestaan - DroidDeck-systeemtoetsen - Houdt Alt+Tab, de Win-toets en de Home-knop in een actieve DroidDeck-sessie in plaats van Android. Zet Helderheid aan in Installatie → Steam-integratie Mali-brug: uit %1$s kan de Mali-brug niet gebruiken (die heeft een Mali-GPU nodig zonder route via de systeemdriver), dus deze schakelaar heeft hier geen effect. @@ -3999,10 +4024,11 @@ Posities herstellen Label tonen Deze indeling kan niet worden geïmporteerd + Wordt geïnstalleerd via %1$s Scharlakenrode sneeuw Witte oppervlakken met rode accenten. - + Soundtracks Muziek Afspeelopties diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index de994d5239..0b27fa7f0e 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -9,15 +9,35 @@ Nie udało się automatycznie uruchomić ponownie DroidDeck. Całkowicie zamknij aplikację, a potem otwórz ją ponownie. DroidDeck - Przy pierwszym uruchomieniu pobierany jest Steam. Może to potrwać kilka minut. - Domyślnie wyjście z aplikacji wstrzymuje Steam; po powrocie wznowi on działanie tam, gdzie przerwał. - Twój kontroler jest widoczny jako pad Xbox 360. Bez niego użyj sterowania ekranowego. + Pierwsze uruchomienie pobiera Steam. Może to potrwać kilka minut. + Twój kontroler jest widoczny dla Steam jako kontroler Steam Deck. W ustawieniach sesji przełącz go na Steam Controller, DualShock 4, DualSense lub pad Xbox 360; zmiana działa od następnej sesji. + Przytrzymaj Wstecz na kontrolerze, aby otworzyć menu Szybki dostęp Steam. Opcja Przytrzymaj Wstecz dla skrótów Steam musi być włączona w ustawieniach sesji. + Działanie w tle decyduje, co się dzieje po wyjściu z aplikacji: Natywnie przygotowuje Steam do uśpienia, Auto wstrzymuje go, Ręcznie czeka na Wznów, Nigdy pozostawia go uruchomionego. + Gry Steam używają Limitu klatek Steam w menu Szybki dostęp. Ekran przełącza się na częstotliwość odświeżania, przez którą limit dzieli się równo, jeśli taka istnieje. + Tryb niskiego opóźnienia w menu sesji wysyła dane z kontrolera z częstotliwością 1000 Hz zamiast 250 Hz, kosztem nieco większego zużycia CPU i baterii. + Każda gra ma własny profil z Proton, FEX, komponentami i ustawieniami środowiska. + Menu sesji ma przełącznik mikrofonu do czatu głosowego i przycisk Wstrzymaj teraz, który zamraża sesję na żądanie. + Przeciągnij HUD DroidDeck, aby go przesunąć, ściągnij palce, aby zmienić rozmiar, i przesuń go za krawędź, aby zadokować go jako małą kartę FPS. + Na konsolach z dwoma ekranami dolny ekran może pokazywać pobieranie, powiadomienia, zrzuty ekranu i czat Steam. Opcja Zamień ekrany przenosi tam grę. + Dodaj biblioteki Steam z karty SD, dysku USB lub SSD, a DroidDeck zbierze gry razem w Twojej Bibliotece. + Sklepy pozwalają zalogować się do Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io i Game Jolt, a następnie instalować i aktualizować ich gry z poziomu DroidDeck. + Komponenty takie jak FEX, DXVK i VKD3D-Proton aktualizują się same, a domyślny jest Proton Experimental ARM64 albo Proton 11.0 ARM64, gdy ta wersja jest zainstalowana. + Kompresuj Steam podczas gry zwalnia pamięć RAM na urządzeniach, którym jej brakuje. + Przesuń palcem od prawej krawędzi, aby otworzyć menu sesji: tryb touchpada, Klawiatura PC, Tryb niskiego opóźnienia, profil gry i więcej. + Gra działa wolno? Ogranicz liczbę klatek w menu Szybki dostęp, a potem wypróbuj inną wersję Proton lub inny preset FEX w komponentach gry. + Trzaski lub brak dźwięku w grze? Wypróbuj przełącznik DirectAudio dla gier w ustawieniach Steam w sekcji Dźwięk. + Konfiguracja, a potem Pamięć, może wyczyścić pamięci podręczne shaderów i pozostałe prefiksy po usuniętych grach. + Znalazłeś błąd? Udostępnij logi w menu sesji tworzy pakiet diagnostyczny. Opublikuj go w #bug-reports na Discord. - Przy pierwszym uruchomieniu konfigurowany jest pulpit. Może to potrwać kilka minut. - Domyślnie wyjście z aplikacji wstrzymuje sesję; po powrocie wznowi się ona tam, gdzie została przerwana. - Ekran działa jak touchpad: przeciągnij, aby przesunąć kursor, dotknij, aby kliknąć. - Twój kontroler jest widoczny jako pad Xbox 360. Bez niego użyj sterowania ekranowego. + Pierwsze uruchomienie konfiguruje pulpit. Może to potrwać kilka minut. + Dotyk działa jak touchpad: przeciągnij, aby przesunąć wskaźnik, stuknij, aby kliknąć. + Działanie w tle decyduje, co się dzieje po wyjściu z aplikacji: Ręcznie domyślnie czeka na Wznów, Auto wstrzymuje, Nigdy pozostawia uruchomione. + Przesuń palcem od prawej krawędzi, aby otworzyć menu sesji, a następnie wybierz Klawiatura PC, aby pisać w aplikacjach ignorujących klawiaturę Androida. + Klawiatura PC w menu sesji ma regulowany rozmiar, przezroczystość i grupy klawiszy. + Twój kontroler jest widoczny jako pad Xbox 360. W przeciwnym razie użyj sterowania ekranowego. + Menu sesji ma przełącznik mikrofonu i przycisk Wstrzymaj teraz, który zamraża sesję na żądanie. + Znalazłeś błąd? Udostępnij logi w menu sesji tworzy pakiet diagnostyczny. Opublikuj go w #bug-reports na Discord. Sesja Widoczne, gdy otwarta jest sesja Steam lub pulpitu @@ -269,6 +289,10 @@ Touchpad Bezpośredni Auto: touchpad na pulpicie, bezpośredni w Steam. + Rysik + Mysz + Dotyk + Przycisk boczny Sterowanie ekranowe Steam + QAM Auto pokazuje sterowanie, gdy nie jest podłączony żaden kontroler. @@ -608,6 +632,8 @@ Wyłączony Domyślny sterownika Kompresuj Steam podczas gry + Kompresuj nieużywaną pamięć gry + Kompresuje nieużywaną pamięć gry przy małej ilości RAM. Wyłącz, jeśli gry zawieszają się na kilka sekund mniej więcej co pół minuty. Działa od następnego uruchomienia sesji. 20 s po starcie gry klient Steam jest kompresowany do zRAM, aby zostawić grze więcej pamięci, i wczytywany z powrotem po zamknięciu gry. Wyłącz, jeśli sesja zamyka się wkrótce po starcie gier. Powyższy limit RAM nadal kompresuje Steam, gdy sesja go przekroczy. Limit RAM Działa, gdy działa klient Steam, w trybie Steam lub z pulpitu. Gdy sesja używa więcej, Steam, a następnie inne obsługiwane procesy sesji są kompresowane do zRAM. Miękki limit: nic nie jest zamykane, ale gry mogą się zacinać podczas wczytywania stron z powrotem. @@ -618,7 +644,7 @@ Tylko Adreno. Mniej przycięć, większe zużycie baterii i więcej ciepła. Poprawki sesji Turnip: renderowanie sysmem - Szybsze dla klienta Steam; w grach sterownik dla każdego przebiegu wybiera renderowanie kafelkowe lub w pamięci systemowej. Wymagane na Adreno 710/720/722. + Dotyczy klienta Steam i gier. Wymagane na Adreno 710/720/722. Pomijaj pomocnika xalia w Steam droiddeck-ntsync Zastępnik sterownika Linux ntsync w przestrzeni użytkownika. Gdy jest włączony, Proton używa go zamiast droiddeck-esync i droiddeck-fsync. Zgodny z Proton Experimental ARM64, GE-Proton i proton-cachyos. Działa od następnej sesji. @@ -1872,6 +1898,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Wyczyść Najpierw zainstaluj środowisko Biblioteka Steam jest niedostępna Poprzednia biblioteka na karcie SD jest niedostępna @@ -3915,8 +3942,6 @@ Alt+Tab, klawisz Win i przycisk Home pozostają w sesji Wyszarzone w Androidzie? Informacje o aplikacji → ⋮ → Zezwól na ustawienia z ograniczeniami Zablokowane przez Androida · Informacje o aplikacji → ⋮ → Zezwól na ustawienia z ograniczeniami - Klawisze systemowe DroidDeck - Zatrzymuje Alt+Tab, klawisz Win i przycisk Home w aktywnej sesji DroidDeck zamiast w Androidzie. Włącz Jasność w Konfiguracja → Integracja ze Steam Most Mali: wył. %1$s nie może używać mostku Mali (wymaga GPU Mali bez ścieżki sterownika systemowego), więc ten przełącznik nic tu nie zmienia. @@ -4079,10 +4104,11 @@ Resetuj położenie Pokaż etykietę Nie można zaimportować tego układu + Instalacja przez %1$s Szkarłatny śnieg Białe powierzchnie z czerwonymi akcentami. - + Ścieżki dźwiękowe Muzyka Opcje odtwarzania diff --git a/app/src/main/res/values-pt-rPT/strings.xml b/app/src/main/res/values-pt-rPT/strings.xml index dc549260d8..29c45ede21 100644 --- a/app/src/main/res/values-pt-rPT/strings.xml +++ b/app/src/main/res/values-pt-rPT/strings.xml @@ -9,15 +9,35 @@ O DroidDeck não conseguiu reiniciar automaticamente. Feche completamente a app e volte a abri-la. DroidDeck - A primeira execução transfere o Steam. Isto pode demorar alguns minutos. - Por predefinição, sair da app coloca o Steam em pausa; ao voltar, continua onde ficou. - O seu comando aparece como um comando Xbox 360. Se não tiver comando, utilize os controlos no ecrã. + Na primeira execução, o Steam é transferido. Isto pode demorar alguns minutos. + O seu comando aparece para o Steam como um comando do Steam Deck. Mude para um Steam Controller, DualShock 4, DualSense ou comando Xbox 360 nas definições da sessão; aplica-se na sessão seguinte. + Mantenha Voltar premido no comando para abrir o menu Acesso rápido do Steam. A opção Manter Voltar premido para atalhos do Steam tem de estar ativada nas definições da sessão. + Comportamento em segundo plano define o que acontece quando sai da app: Nativo prepara o Steam para suspensão, Automático pausa-o, Manual espera por Retomar, Nunca mantém-no em execução. + Os jogos Steam usam o Limite de fotogramas do Steam no Acesso rápido. O ecrã muda para uma taxa de atualização que o limite divida por igual, quando existe uma. + O Modo de baixa latência no menu da sessão envia a entrada do comando a 1000 Hz em vez de 250 Hz, com um pouco mais de CPU e bateria. + Cada jogo tem o seu próprio perfil com Proton, FEX, componentes e definições de ambiente. + O menu da sessão tem um botão de microfone para conversa por voz e um botão Suspender agora para congelar a sessão quando quiser. + Arraste o HUD do DroidDeck para o mover, junte os dedos em pinça para o redimensionar e empurre-o para um limite do ecrã para o fixar como um pequeno separador de FPS. + Em consolas portáteis com dois ecrãs, o ecrã de baixo pode mostrar transferências, notificações, capturas de ecrã e a conversa do Steam. Trocar ecrãs coloca lá o jogo. + Adicione bibliotecas Steam de um cartão SD, unidade USB ou SSD, e o DroidDeck mantém os jogos juntos na sua Biblioteca. + Lojas permite iniciar sessão no Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io e Game Jolt, e depois instalar e atualizar os jogos deles a partir do DroidDeck. + Componentes como FEX, DXVK e VKD3D-Proton atualizam-se sozinhos, e o Proton Experimental ARM64 é o predefinido, ou o Proton 11.0 ARM64 quando essa versão estiver instalada. + Comprimir o Steam durante um jogo liberta RAM em dispositivos com pouca memória. + Deslize a partir do limite direito para abrir o menu da sessão: modo de painel tátil, Teclado de PC, Modo de baixa latência, perfil do jogo e mais. + O jogo está lento? Limite a taxa de fotogramas no Acesso rápido e experimente outra versão do Proton ou outra predefinição do FEX nos componentes do jogo. + Áudio do jogo com estalidos ou ausente? Experimente a opção DirectAudio para jogos nas definições do Steam, em Áudio. + Configuração, e depois Armazenamento, pode limpar caches de shaders e prefixos restantes de jogos que removeu. + Encontrou um erro? Partilhar registos no menu da sessão reúne os diagnósticos. Publique-os em #bug-reports no Discord. - A primeira execução configura o ambiente de trabalho. Isto pode demorar alguns minutos. - Por predefinição, sair da app coloca a sessão em pausa; ao voltar, continua onde ficou. - O toque funciona como um painel tátil: arraste para mover o ponteiro, toque para clicar. - O seu comando aparece como um comando Xbox 360. Se não tiver comando, utilize os controlos no ecrã. + Na primeira execução, o ambiente de trabalho é configurado. Isto pode demorar alguns minutos. + O toque funciona como painel tátil: arraste para mover o ponteiro, toque para clicar. + Comportamento em segundo plano define o que acontece quando sai da app: Manual espera por Retomar por predefinição, Automático pausa, Nunca mantém em execução. + Deslize a partir do limite direito para abrir o menu da sessão e escolha Teclado de PC para escrever em apps que ignoram o teclado do Android. + O Teclado de PC no menu da sessão tem tamanho, opacidade e grupos de teclas ajustáveis. + O seu comando aparece como um comando Xbox 360. Caso contrário, use os controlos no ecrã. + O menu da sessão tem um botão de microfone e um botão Suspender agora para congelar a sessão quando quiser. + Encontrou um erro? Partilhar registos no menu da sessão reúne os diagnósticos. Publique-os em #bug-reports no Discord. Sessão Apresentada enquanto houver uma sessão do Steam ou do ambiente de trabalho aberta @@ -269,6 +289,10 @@ Painel tátil Direto Automático: painel tátil no Ambiente de trabalho, direto no Steam. + Caneta + Rato + Toque + Botão lateral Controlos no ecrã Steam + QAM Em Automático, os controlos aparecem quando não há nenhum comando ligado. @@ -606,6 +630,8 @@ Desativado Predefinição do controlador Comprimir o Steam durante um jogo + Comprimir memória inativa do jogo + Comprime a memória inativa do jogo quando há pouca RAM. Desative se os jogos bloquearem durante alguns segundos aproximadamente a cada meio minuto. Aplica-se no próximo início da sessão. 20 s após o início de um jogo, o cliente Steam é comprimido na zRAM para deixar mais memória ao jogo, e é lido de volta quando o jogo fecha. Desative se a sessão fechar pouco depois de os jogos iniciarem. Um limite de RAM acima continua a comprimir o Steam quando a sessão o ultrapassa. Limite de RAM Aplica-se enquanto o cliente Steam está em execução, no modo Steam ou a partir do ambiente de trabalho. Quando a sessão utiliza mais do que isto, o Steam e depois os outros processos suportados da sessão são comprimidos na zRAM. Um limite flexível: nada é fechado, mas os jogos podem ter soluços enquanto as páginas são repostas. @@ -616,7 +642,7 @@ Apenas Adreno. Menos soluços, mais consumo de bateria e mais calor. Correções da sessão Turnip: renderização em sysmem - Mais rápido para o cliente Steam; nos jogos, o controlador escolhe em cada passagem entre renderização em mosaico ou na memória do sistema. Obrigatório no Adreno 710/720/722. + Aplica-se ao cliente Steam e aos jogos. Obrigatório no Adreno 710/720/722. Ignorar o assistente xalia do Steam droiddeck-ntsync Um substituto em espaço de utilizador para o controlador ntsync do Linux. Enquanto estiver ativado, o Proton utiliza-o em vez do droiddeck-esync e do droiddeck-fsync. Funciona com o Proton Experimental ARM64, o GE-Proton e o proton-cachyos. Aplica-se na próxima sessão. @@ -1844,6 +1870,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Limpar Instale primeiro o runtime A biblioteca do Steam não está disponível A biblioteca anterior do cartão SD não está disponível @@ -3875,8 +3902,6 @@ Alt+Tab, tecla Win e botão Início ficam na sessão Desativado a cinzento no Android? Informações da aplicação → ⋮ → Permitir definições restritas Bloqueado pelo Android · Informações da aplicação → ⋮ → Permitir definições restritas - Teclas do sistema DroidDeck - Mantém Alt+Tab, a tecla Win e o botão Início numa sessão ativa do DroidDeck em vez do Android. Ative Brilho em Configuração → Integração com o Steam Ponte Mali: desligada %1$s não pode usar a ponte Mali (é necessária uma GPU Mali sem rota de controlador do sistema), por isso este interruptor não tem efeito aqui. @@ -4038,10 +4063,11 @@ Repor posições Mostrar etiqueta Não foi possível importar este esquema + Instala-se através de %1$s Neve Escarlate Superfícies brancas com detalhes vermelhos. - + Bandas sonoras Música Opções de reprodução diff --git a/app/src/main/res/values-pt/strings.xml b/app/src/main/res/values-pt/strings.xml index 7f8d3196b6..f966fabc05 100644 --- a/app/src/main/res/values-pt/strings.xml +++ b/app/src/main/res/values-pt/strings.xml @@ -10,14 +10,34 @@ DroidDeck Na primeira execução, a Steam é baixada. Isso pode levar alguns minutos. - Por padrão, sair do app pausa a Steam; ela continua de onde parou quando você voltar. - Seu controle aparece como um controle de Xbox 360. Sem controle, use os controles na tela. + Seu controle aparece para a Steam como um controle do Steam Deck. Troque para um Steam Controller, DualShock 4, DualSense ou controle Xbox 360 nas configurações da sessão; vale a partir da próxima sessão. + Segure Voltar no controle para abrir o menu Acesso rápido da Steam. A opção Segurar Voltar para atalhos do Steam precisa estar ativada nas configurações da sessão. + Comportamento em segundo plano define o que acontece ao sair do app: Nativo prepara a Steam para dormir, Automático a pausa, Manual espera por Retomar, Nunca a mantém em execução. + Jogos da Steam usam o Limite de quadros da Steam no Acesso rápido. A tela muda para uma taxa de atualização que o limite divida igualmente, quando existe uma. + O Modo de baixa latência no menu da sessão envia a entrada do controle a 1000 Hz em vez de 250 Hz, com um pouco mais de CPU e bateria. + Cada jogo tem seu próprio perfil com Proton, FEX, componentes e configurações de ambiente. + O menu da sessão tem um botão de microfone para bate-papo por voz e um botão Suspender agora para congelar a sessão quando quiser. + Arraste o HUD do DroidDeck para movê-lo, faça o gesto de pinça para redimensioná-lo e empurre-o para uma borda para fixá-lo como uma pequena aba de FPS. + Em portáteis com duas telas, a tela de baixo pode mostrar downloads, notificações, capturas de tela e o chat da Steam. Trocar telas coloca o jogo lá embaixo. + Adicione bibliotecas da Steam de um cartão SD, pen drive USB ou SSD, e o DroidDeck mantém os jogos juntos na sua Biblioteca. + Lojas permite entrar no Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io e Game Jolt, e depois instalar e atualizar os jogos deles pelo DroidDeck. + Componentes como FEX, DXVK e VKD3D-Proton se atualizam sozinhos, e o Proton Experimental ARM64 é o padrão, ou o Proton 11.0 ARM64 quando essa versão estiver instalada. + Comprimir a Steam durante o jogo libera RAM em dispositivos com pouca memória. + Deslize da borda direita para abrir o menu da sessão: modo touchpad, Teclado de PC, Modo de baixa latência, perfil do jogo e mais. + Jogo rodando devagar? Limite a taxa de quadros no Acesso rápido e depois teste outra versão do Proton ou outra predefinição do FEX nos componentes do jogo. + Áudio do jogo com chiado ou sem som? Experimente a opção DirectAudio para jogos nas configurações da Steam, em Áudio. + Configuração, e depois Armazenamento, pode limpar caches de shaders e prefixos restantes de jogos que você removeu. + Encontrou um bug? Compartilhar logs no menu da sessão reúne os diagnósticos. Publique-os em #bug-reports no Discord. - Na primeira execução, a área de trabalho é preparada. Isso pode levar alguns minutos. - Por padrão, sair do app pausa a sessão; ela continua de onde parou quando você voltar. - O toque funciona como um touchpad: arraste para mover o ponteiro, toque para clicar. - Seu controle aparece como um controle de Xbox 360. Sem controle, use os controles na tela. + Na primeira execução, a área de trabalho é configurada. Isso pode levar alguns minutos. + O toque funciona como touchpad: arraste para mover o ponteiro, toque para clicar. + Comportamento em segundo plano define o que acontece ao sair do app: Manual espera por Retomar por padrão, Automático pausa, Nunca mantém em execução. + Deslize da borda direita para abrir o menu da sessão e escolha Teclado de PC para digitar em apps que ignoram o teclado do Android. + O Teclado de PC no menu da sessão tem tamanho, opacidade e grupos de teclas ajustáveis. + Seu controle aparece como um controle Xbox 360. Caso contrário, use os controles na tela. + O menu da sessão tem um botão de microfone e um botão Suspender agora para congelar a sessão quando quiser. + Encontrou um bug? Compartilhar logs no menu da sessão reúne os diagnósticos. Publique-os em #bug-reports no Discord. Sessão Aparece enquanto uma sessão da Steam ou da área de trabalho está aberta @@ -269,6 +289,10 @@ Touchpad Direto Automático: touchpad na Área de trabalho, direto na Steam. + Caneta + Mouse + Toque + Botão lateral Controles na tela Steam + QAM No Automático, os controles na tela aparecem quando não há um controle conectado. @@ -606,6 +630,8 @@ Desativado Padrão do driver Comprimir a Steam durante o jogo + Comprimir memória inativa do jogo + Comprime a memória inativa do jogo quando há pouca RAM. Desative se os jogos travarem por alguns segundos a cada meio minuto, aproximadamente. Vale a partir do próximo início da sessão. 20 s após o início de um jogo, o cliente Steam é comprimido na zRAM para deixar mais memória ao jogo, e é lido de volta quando o jogo fecha. Desative se a sessão fechar logo após os jogos iniciarem. Um limite de RAM acima ainda comprime a Steam quando a sessão o ultrapassa. Limite de RAM Vale enquanto o cliente Steam está em execução, no modo Steam ou pela área de trabalho. Quando a sessão usa mais que isso, a Steam e depois os outros processos compatíveis da sessão são comprimidos na zRAM. Um limite flexível: nada é fechado, mas os jogos podem travar enquanto as páginas voltam. @@ -616,7 +642,7 @@ Só em Adreno. Menos engasgos, mais gasto de bateria e mais calor. Correções da sessão Turnip: renderização sysmem - Mais rápido para o cliente da Steam; nos jogos, o driver escolhe a cada passagem entre renderização em blocos ou na memória do sistema. Obrigatório nas Adreno 710/720/722. + Aplica-se ao cliente Steam e aos jogos. Obrigatório nas Adreno 710/720/722. Pular o assistente xalia da Steam droiddeck-ntsync Um substituto em espaço de usuário para o driver ntsync do Linux. Enquanto estiver ativado, o Proton o usa no lugar do droiddeck-esync e do droiddeck-fsync. Funciona com o Proton Experimental ARM64, o GE-Proton e o proton-cachyos. Vale a partir da próxima sessão. @@ -740,6 +766,13 @@ Redefinir Modo de escala Nitidez da escala + Perfil de efeitos + Escolha qual perfil terá os efeitos de tela editados. + Jogo atual (automático) + Redefinir efeitos + Define os efeitos deste perfil como desativados por padrão. + Excluir configuração salva + Remove os efeitos salvos deste jogo para ele herdar o perfil padrão. Efeitos de tela Em tempo real. Custa um pouco de tempo de GPU enquanto algum efeito estiver ativado. Predefinições @@ -1845,6 +1878,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Limpar Instale o runtime primeiro A biblioteca do Steam não está disponível A biblioteca anterior no cartão SD não está disponível @@ -3876,8 +3910,6 @@ Alt+Tab, tecla Win e botão Início ficam na sessão Esmaecido no Android? Informações do app → ⋮ → Permitir configurações restritas Bloqueado pelo Android · Informações do app → ⋮ → Permitir configurações restritas - Teclas do sistema DroidDeck - Mantém Alt+Tab, a tecla Win e o botão Início em uma sessão ativa do DroidDeck em vez do Android. Ative Brilho em Configuração → Integração com a Steam Ponte Mali: desligada %1$s não pode usar a ponte Mali (ela precisa de uma GPU Mali sem uma rota de driver do sistema), por isso esta chave não tem efeito aqui. @@ -4039,10 +4071,11 @@ Redefinir posições Mostrar rótulo Não foi possível importar este layout + Instala-se através de %1$s Neve Escarlate Superfícies brancas com detalhes em vermelho. - + Trilhas sonoras Música Opções de reprodução diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index 9c28d24295..8f560e9cbb 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -9,15 +9,35 @@ DroidDeck nu a putut reporni automat. Închide complet aplicația, apoi redeschide-o. DroidDeck - Prima rulare descarcă Steam. Poate dura câteva minute. - În mod implicit, la părăsirea aplicației, Steam este pus pe pauză; continuă de unde ai rămas când te întorci. - Controllerul tău apare ca un gamepad Xbox 360. Altfel, folosește comenzile de pe ecran. + La prima rulare se descarcă Steam. Poate dura câteva minute. + Controllerul tău apare în Steam ca un controller Steam Deck. Schimbă-l pe un Steam Controller, DualShock 4, DualSense sau Xbox 360 din setările sesiunii; se aplică de la sesiunea următoare. + Ține apăsat Înapoi pe controller pentru a deschide meniul Acces rapid din Steam. Ține apăsat Înapoi pentru comenzi Steam trebuie să fie activat în setările sesiunii. + Comportament în fundal decide ce se întâmplă când părăsești aplicația: Nativ pregătește Steam pentru repaus, Automat îl pune în pauză, Manual așteaptă Reluare, Niciodată îl lasă să ruleze. + Jocurile Steam folosesc Limita de cadre din Steam, în Acces rapid. Ecranul trece la o rată de reîmprospătare pe care limita o împarte exact, când există una. + Mod latență redusă din meniul sesiunii trimite intrările controllerului la 1000 Hz în loc de 250 Hz, cu puțin mai mult CPU și baterie. + Fiecare joc are propriul profil, cu Proton, FEX, componente și setări de mediu. + Meniul sesiunii are un comutator pentru microfon, pentru chat vocal, și un buton Suspendă acum, ca să îngheți sesiunea la cerere. + Trage HUD-ul DroidDeck ca să-l muți, ciupește ca să-l redimensionezi și împinge-l peste o margine ca să-l ancorezi ca o mică filă FPS. + Pe consolele portabile cu două ecrane, ecranul de jos poate afișa descărcări, notificări, capturi de ecran și chatul Steam. Schimbă ecranele mută jocul acolo. + Adaugă biblioteci Steam de pe un card SD, o unitate USB sau un SSD, iar DroidDeck păstrează jocurile împreună în Biblioteca ta. + Magazine îți permite să te conectezi la Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io și Game Jolt, apoi să instalezi și să actualizezi jocurile lor din DroidDeck. + Componente precum FEX, DXVK și VKD3D-Proton se actualizează singure, iar Proton Experimental ARM64 este implicit, sau Proton 11.0 ARM64 odată ce acea versiune este instalată. + Comprimă Steam cât rulează un joc eliberează RAM pe dispozitivele cu memorie puțină. + Glisează dinspre marginea dreaptă ca să deschizi meniul sesiunii: mod touchpad, Tastatură de PC, Mod latență redusă, profilul jocului și altele. + Jocul rulează greu? Limitează rata de cadre în Acces rapid, apoi încearcă altă versiune de Proton sau alt preset FEX în componentele jocului. + Sunet de joc cu pârâituri sau lipsă? Încearcă opțiunea DirectAudio pentru jocuri din setările Steam, la Sunet. + Configurare, apoi Stocare, poate șterge cache-urile de shadere și prefixele rămase de la jocurile eliminate. + Ai dat de o eroare? Partajează jurnalele din meniul sesiunii strânge diagnosticele. Postează-le în #bug-reports pe Discord. - Prima rulare configurează desktopul. Poate dura câteva minute. - În mod implicit, la părăsirea aplicației, sesiunea este pusă pe pauză; continuă de unde ai rămas când te întorci. - Atingerea funcționează ca un touchpad: trage pentru a mișca cursorul, apasă scurt pentru a face clic. - Controllerul tău apare ca un gamepad Xbox 360. Altfel, folosește comenzile de pe ecran. + La prima rulare se configurează desktopul. Poate dura câteva minute. + Atingerea funcționează ca un touchpad: trage ca să muți cursorul, atinge ca să dai clic. + Comportament în fundal decide ce se întâmplă când părăsești aplicația: Manual așteaptă Reluare în mod implicit, Automat pune în pauză, Niciodată lasă să ruleze. + Glisează dinspre marginea dreaptă ca să deschizi meniul sesiunii, apoi alege Tastatură de PC ca să scrii în aplicațiile care ignoră tastatura Android. + Tastatura de PC din meniul sesiunii are dimensiune, opacitate și grupuri de taste reglabile. + Controllerul tău apare ca un controller Xbox 360. Altfel, folosește comenzile de pe ecran. + Meniul sesiunii are un comutator pentru microfon și un buton Suspendă acum, ca să îngheți sesiunea la cerere. + Ai dat de o eroare? Partajează jurnalele din meniul sesiunii strânge diagnosticele. Postează-le în #bug-reports pe Discord. Sesiune Apare cât timp o sesiune Steam sau desktop este activă @@ -269,6 +289,10 @@ Touchpad Direct Automat: touchpad pe Desktop, direct în Steam. + Stilou + Mouse + Atingere + Buton lateral Comenzi pe ecran Steam + QAM Automat afișează comenzile când niciun controller nu este conectat. @@ -606,6 +630,8 @@ Dezactivat Implicit driver Comprimă Steam cât rulează un joc + Comprimă memoria inactivă a jocului + Comprimă memoria inactivă a jocului când memoria RAM este redusă. Dezactivează dacă jocurile îngheață câteva secunde aproximativ la fiecare jumătate de minut. Se aplică la următoarea pornire a sesiunii. La 20 s după pornirea unui joc, clientul Steam este comprimat în zRAM pentru a lăsa jocului mai multă memorie și este citit înapoi când jocul se închide. Dezactivează dacă sesiunea se închide la scurt timp după pornirea jocurilor. O limită RAM de mai sus tot comprimă Steam când sesiunea o depășește. Limită RAM Se aplică cât rulează clientul Steam, în modul Steam sau de pe desktop. Când sesiunea folosește mai mult de atât, Steam și apoi celelalte procese acceptate ale sesiunii sunt comprimate în zRAM. O limită flexibilă: nimic nu se închide, dar jocurile pot sacada cât paginile revin. @@ -616,7 +642,7 @@ Doar Adreno. Mai puține întreruperi, consum mai mare de baterie și căldură. Remedieri de sesiune Turnip: randare sysmem - Mai rapidă pentru clientul Steam; în jocuri, driverul alege la fiecare trecere între randarea pe dale și cea în memoria sistemului. Necesară pe Adreno 710/720/722. + Se aplică clientului Steam și jocurilor. Necesară pe Adreno 710/720/722. Omite asistentul xalia al Steam droiddeck-ntsync Un substitut la nivel de utilizator pentru driverul Linux ntsync. Cât timp este activ, Proton îl folosește în locul droiddeck-esync și droiddeck-fsync. Funcționează cu Proton Experimental ARM64, GE-Proton și proton-cachyos. Se aplică la sesiunea următoare. @@ -1853,6 +1879,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Golește Instalează mai întâi mediul de execuție Biblioteca Steam nu este disponibilă Biblioteca SD anterioară nu este disponibilă @@ -3876,8 +3903,6 @@ Alt+Tab, tasta Win și butonul Acasă rămân în sesiune Inactiv în Android? Informații despre aplicație → ⋮ → Permite setările restricționate Blocat de Android · Informații despre aplicație → ⋮ → Permite setările restricționate - Taste de sistem DroidDeck - Păstrează Alt+Tab, tasta Win și butonul Acasă într-o sesiune DroidDeck activă în loc de Android. Activează Luminozitate în Configurare → Integrare Steam Punte Mali: oprită %1$s nu poate folosi puntea Mali (are nevoie de un GPU Mali fără o rută prin driverul de sistem), deci acest comutator nu are niciun efect aici. @@ -4039,10 +4064,11 @@ Resetează pozițiile Afișează eticheta Acest aranjament nu a putut fi importat + Se instalează prin %1$s Zăpadă stacojie Suprafețe albe cu accente roșii. - + Coloane sonore Muzică Opțiuni de redare diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 8a98c2b2a2..3023e72f1f 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -9,15 +9,35 @@ Не удалось автоматически перезапустить DroidDeck. Полностью закройте приложение и откройте его снова. DroidDeck - При первом запуске будет загружен Steam. Это может занять несколько минут. - По умолчанию при выходе из приложения Steam приостанавливается; при возвращении работа возобновляется с того же места. - Ваш контроллер отображается как геймпад Xbox 360. Если контроллера нет, используйте экранные элементы управления. + При первом запуске загружается Steam. Это может занять несколько минут. + Ваш контроллер отображается в Steam как контроллер Steam Deck. В настройках сеанса переключите его на Steam Controller, DualShock 4, DualSense или геймпад Xbox 360; изменение вступит в силу со следующего сеанса. + Удерживайте «Назад» на контроллере, чтобы открыть меню «Быстрый доступ» Steam. Параметр «Удержание «Назад» для сочетаний Steam» должен быть включён в настройках сеанса. + «Поведение в фоне» определяет, что происходит при выходе из приложения: «Штатный» готовит Steam ко сну, «Авто» ставит его на паузу, «Вручную» ждёт «Продолжить», «Никогда» оставляет его работать. + Игры Steam используют «Ограничение кадров» Steam в меню «Быстрый доступ». Экран переключается на частоту обновления, на которую ограничение делится без остатка, если такая есть. + «Режим низкой задержки» в меню сеанса передаёт ввод с контроллера с частотой 1000 Гц вместо 250 Гц ценой небольшой нагрузки на процессор и аккумулятор. + У каждой игры есть свой профиль с Proton, FEX, компонентами и настройками окружения. + В меню сеанса есть переключатель микрофона для голосового чата и кнопка «Приостановить сейчас», чтобы заморозить сеанс по требованию. + Перетащите HUD DroidDeck, чтобы переместить его, сведите пальцы, чтобы изменить размер, и сдвиньте за край, чтобы закрепить его маленькой вкладкой FPS. + На портативных консолях с двумя экранами нижний экран может показывать загрузки, уведомления, скриншоты и чат Steam. «Поменять экраны местами» переносит игру вниз. + Добавляйте библиотеки Steam с SD-карты, USB-накопителя или SSD, и DroidDeck соберёт игры вместе в вашей «Библиотеке». + «Магазины» позволяют войти в Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io и Game Jolt, а затем устанавливать и обновлять их игры из DroidDeck. + Компоненты вроде FEX, DXVK и VKD3D-Proton обновляются сами, а по умолчанию используется Proton Experimental ARM64 или Proton 11.0 ARM64, когда эта сборка установлена. + «Сжимать Steam во время игры» освобождает ОЗУ на устройствах с нехваткой памяти. + Проведите от правого края, чтобы открыть меню сеанса: режим тачпада, «Клавиатура ПК», «Режим низкой задержки», профиль игры и другое. + Игра тормозит? Ограничьте частоту кадров в меню «Быстрый доступ», затем попробуйте другую версию Proton или другой пресет FEX в компонентах игры. + Треск или нет звука в игре? Попробуйте переключатель «DirectAudio для игр» в настройках Steam в разделе «Аудио». + «Настройка», а затем «Хранилище» могут очистить кэши шейдеров и остатки префиксов от удалённых игр. + Нашли ошибку? «Поделиться журналами» в меню сеанса собирает диагностику. Опубликуйте её в #bug-reports в Discord. - При первом запуске будет настроен рабочий стол. Это может занять несколько минут. - По умолчанию при выходе из приложения сессия приостанавливается; при возвращении работа возобновляется с того же места. - Сенсорный ввод работает как тачпад: перетаскивайте для перемещения курсора, нажимайте для клика. - Ваш контроллер отображается как геймпад Xbox 360. Если контроллера нет, используйте экранные элементы управления. + При первом запуске настраивается рабочий стол. Это может занять несколько минут. + Касание работает как тачпад: проведите пальцем, чтобы переместить указатель, коснитесь, чтобы щёлкнуть. + «Поведение в фоне» определяет, что происходит при выходе из приложения: «Вручную» по умолчанию ждёт «Продолжить», «Авто» ставит на паузу, «Никогда» оставляет работать. + Проведите от правого края, чтобы открыть меню сеанса, затем выберите «Клавиатура ПК», чтобы вводить текст в приложениях, игнорирующих клавиатуру Android. + У «Клавиатуры ПК» в меню сеанса настраиваются размер, прозрачность и группы клавиш. + Ваш контроллер отображается как геймпад Xbox 360. Иначе используйте элементы управления на экране. + В меню сеанса есть переключатель микрофона и кнопка «Приостановить сейчас», чтобы заморозить сеанс по требованию. + Нашли ошибку? «Поделиться журналами» в меню сеанса собирает диагностику. Опубликуйте её в #bug-reports в Discord. Сессия Отображается, пока открыта сессия Steam или рабочего стола @@ -269,6 +289,10 @@ Тачпад Прямой Авто: тачпад для рабочего стола, прямой сенсорный ввод для Steam. + Перо + Мышь + Сенсорный ввод + Боковая кнопка Экранные элементы управления Steam + QAM Автоматический режим показывает экранные элементы управления, если контроллер не подключен. @@ -608,6 +632,8 @@ Выкл. По умолчанию драйвера Сжимать Steam во время игры + Сжимать неактивную память игры + Сжимает неактивную память игры при нехватке RAM. Отключите, если игры зависают на несколько секунд примерно каждые полминуты. Применяется при следующем запуске сеанса. Через 20 с после запуска игры клиент Steam сжимается в zRAM, чтобы оставить игре больше памяти, и считывается обратно после закрытия игры. Отключите, если сессия закрывается вскоре после запуска игр. Лимит RAM выше всё равно сжимает Steam, когда сессия его превышает. Лимит RAM Действует, пока работает клиент Steam, в режиме Steam или с рабочего стола. Когда сессия использует больше этого значения, Steam, а затем другие поддерживаемые процессы сессии сжимаются в zRAM. Мягкий лимит: ничего не закрывается, но игры могут подтормаживать, пока страницы возвращаются. @@ -618,7 +644,7 @@ Только для Adreno. Меньше подтормаживаний, но больше энергопотребления и нагрева. Исправления сессии Turnip: рендеринг sysmem - Клиент Steam будет быстрее; в играх драйвер для каждого прохода выбирает тайловый рендеринг или рендеринг в системной памяти. Требуется для Adreno 710/720/722. + Применяется к клиенту Steam и играм. Требуется на Adreno 710/720/722. Пропустить помощник xalia в Steam droiddeck-ntsync Замена драйвера ntsync Linux в пространстве пользователя. Пока включено, Proton использует ее вместо droiddeck-esync и droiddeck-fsync. Работает с Proton Experimental ARM64, GE-Proton и proton-cachyos. Вступит в силу в следующей сессии. @@ -1872,6 +1898,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Очистить Сначала установите среду выполнения Библиотека Steam недоступна Предыдущая библиотека на SD-карте недоступна @@ -3915,8 +3942,6 @@ Alt+Tab, клавиша Win и кнопка «Домой» работают в сеансе Неактивно в Android? «О приложении» → ⋮ → «Разрешить доступ к настройкам с ограниченным доступом» Заблокировано Android · «О приложении» → ⋮ → «Разрешить доступ к настройкам с ограниченным доступом» - Системные клавиши DroidDeck - Оставляет Alt+Tab, клавишу Win и кнопку «Домой» в активном сеансе DroidDeck, а не в Android. Включите «Яркость» в «Настройка → Интеграция со Steam» Мост Mali: выкл. %1$s не может использовать мост Mali (для него нужен GPU Mali без маршрута через системный драйвер), поэтому этот переключатель здесь ни на что не влияет. @@ -4079,10 +4104,11 @@ Сбросить положение Показывать подпись Не удалось импортировать эту раскладку + Устанавливается через %1$s Алый снег Белые поверхности с красными акцентами. - + Саундтреки Музыка Параметры воспроизведения diff --git a/app/src/main/res/values-sv/strings.xml b/app/src/main/res/values-sv/strings.xml index 427d722263..47365131be 100644 --- a/app/src/main/res/values-sv/strings.xml +++ b/app/src/main/res/values-sv/strings.xml @@ -9,15 +9,35 @@ DroidDeck kunde inte starta om automatiskt. Stäng appen helt och öppna den sedan igen. DroidDeck - Första starten laddar ned Steam. Det kan ta några minuter. - Som standard pausas Steam när du lämnar appen. Det fortsätter där det slutade när du kommer tillbaka. - Din handkontroll visas som en Xbox 360-kontroll. Annars kan du använda skärmkontrollerna. + Första körningen laddar ner Steam. Det kan ta några minuter. + Din kontroll visas för Steam som en Steam Deck-kontroll. Byt till en Steam Controller-, DualShock 4-, DualSense- eller Xbox 360-kontroll i sessionsinställningarna; det gäller från nästa session. + Håll Bakåt på kontrollen för att öppna Steams Snabbåtkomst-meny. Håll Bakåt för Steam-genvägar måste vara på i sessionsinställningarna. + Bakgrundsbeteende avgör vad som händer när du lämnar appen: Inbyggd förbereder Steam för vila, Auto pausar den, Manuell väntar på Återuppta, Aldrig håller den igång. + Steam-spel använder Steams Bildgräns i Snabbåtkomst. Skärmen växlar till en uppdateringsfrekvens som gränsen delas jämnt av när det finns en. + Läge för låg latens i sessionsmenyn skickar kontrollinmatning med 1000 Hz i stället för 250 Hz, mot lite mer CPU och batteri. + Varje spel har en egen profil med Proton, FEX, komponenter och miljöinställningar. + Sessionsmenyn har en mikrofonknapp för röstchatt och en Pausa nu-knapp för att frysa sessionen när du vill. + Dra DroidDeck-HUD:en för att flytta den, nyp för att ändra storlek och skjut den över en kant för att docka den som en liten FPS-flik. + På handhållna enheter med två skärmar kan nedre skärmen visa nedladdningar, aviseringar, skärmdumpar och Steam-chatt. Byt skärmar lägger spelet där nere i stället. + Lägg till Steam-bibliotek från ett SD-kort, USB-minne eller SSD, så håller DroidDeck ihop spelen i ditt Bibliotek. + Butiker låter dig logga in på Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io och Game Jolt och sedan installera och uppdatera deras spel från DroidDeck. + Komponenter som FEX, DXVK och VKD3D-Proton uppdaterar sig själva, och Proton Experimental ARM64 är standard, eller Proton 11.0 ARM64 när den versionen är installerad. + Komprimera Steam medan ett spel körs frigör RAM på enheter med lite minne. + Svep in från högerkanten för att öppna sessionsmenyn: pekplattsläge, PC-tangentbord, låg latens, spelprofil med mera. + Går spelet långsamt? Begränsa bildfrekvensen i Snabbåtkomst och prova sedan en annan Proton-version eller FEX-förinställning i spelets komponenter. + Knaster eller saknat ljud i spelet? Prova växlaren DirectAudio för spel i Steam-inställningarna under Ljud. + Konfiguration och sedan Lagring kan rensa shader-cachar och kvarglömda prefix från spel du tagit bort. + Stöter du på ett fel? Dela loggar i sessionsmenyn paketerar diagnostik. Posta dem i #bug-reports på Discord. - Första starten konfigurerar skrivbordet. Det kan ta några minuter. - Som standard pausas sessionen när du lämnar appen. Den fortsätter där den slutade när du kommer tillbaka. - Pekskärmen fungerar som en pekplatta: dra för att flytta pekaren, tryck för att klicka. - Din handkontroll visas som en Xbox 360-kontroll. Annars kan du använda skärmkontrollerna. + Första körningen konfigurerar skrivbordet. Det kan ta några minuter. + Beröring fungerar som en pekplatta: dra för att flytta pekaren, tryck för att klicka. + Bakgrundsbeteende avgör vad som händer när du lämnar appen: Manuell väntar på Återuppta som standard, Auto pausar, Aldrig håller den igång. + Svep in från högerkanten för att öppna sessionsmenyn och välj sedan PC-tangentbord för att skriva i appar som ignorerar Android-tangentbordet. + PC-tangentbordet i sessionsmenyn har justerbar storlek, opacitet och tangentgrupper. + Din kontroll visas som en Xbox 360-kontroll. Annars använder du kontrollerna på skärmen. + Sessionsmenyn har en mikrofonknapp och en Pausa nu-knapp för att frysa sessionen när du vill. + Stöter du på ett fel? Dela loggar i sessionsmenyn paketerar diagnostik. Posta dem i #bug-reports på Discord. Session Visas medan en Steam- eller skrivbordssession är öppen @@ -269,6 +289,10 @@ Pekplatta Direkt Auto: pekplatta på skrivbordet, direkt i Steam. + Penna + Mus + Pekskärm + Sidoknapp Skärmkontroller Steam + QAM Auto visar kontrollerna när ingen handkontroll är ansluten. @@ -604,6 +628,8 @@ Av Drivrutinens standard Komprimera Steam medan ett spel körs + Komprimera spelets inaktiva minne + Komprimerar spelets inaktiva minne när RAM-minnet är lågt. Stäng av om spel fryser några sekunder ungefär var halvminut. Gäller nästa gång sessionen startar. 20 s efter att ett spel startat komprimeras Steam-klienten till zRAM för att ge spelet mer minne, och läses tillbaka när spelet stängs. Stäng av om sessionen stängs strax efter att spel startar. En RAM-gräns ovan komprimerar fortfarande Steam när sessionen överskrider den. RAM-gräns Gäller medan Steam-klienten körs, i Steam-läge eller från skrivbordet. När sessionen använder mer än detta komprimeras Steam och sedan sessionens övriga processer som stöds till zRAM. En mjuk gräns: inget stängs, men spel kan hacka medan sidor läses tillbaka. @@ -614,7 +640,7 @@ Bara Adreno. Färre hack, högre batteriförbrukning och mer värme. Sessionsfixar Turnip: sysmem-rendering - Snabbare för Steam-klienten; i spel väljer drivrutinen kakel- eller systemminnesrendering för varje pass. Krävs på Adreno 710/720/722. + Gäller Steam-klienten och spel. Krävs på Adreno 710/720/722. Hoppa över Steams xalia-hjälp droiddeck-ntsync En ersättning i användarutrymmet för Linux ntsync-drivrutinen. Medan det är på använder Proton det i stället för droiddeck-esync och droiddeck-fsync. Fungerar med Proton Experimental ARM64, GE-Proton och proton-cachyos. Gäller från nästa session. @@ -1834,6 +1860,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Rensa Installera körmiljön först Steam-biblioteket är inte tillgängligt Det tidigare SD-biblioteket är inte tillgängligt @@ -3837,8 +3864,6 @@ Alt+Tab, Win-tangenten och Hem-knappen stannar i sessionen Nedtonat i Android? Appinfo → ⋮ → Tillåt begränsade inställningar Blockerat av Android · Appinfo → ⋮ → Tillåt begränsade inställningar - DroidDeck-systemtangenter - Håller Alt+Tab, Win-tangenten och Hem-knappen i en aktiv DroidDeck-session i stället för Android. Slå på Ljusstyrka under Konfiguration → Steam-integration Mali-brygga: av %1$s kan inte använda Mali-bryggan (den kräver en Mali-GPU utan en väg via systemdrivrutinen), så det här reglaget har ingen effekt här. @@ -3999,10 +4024,11 @@ Återställ positioner Visa etikett Det gick inte att importera layouten + Installeras via %1$s Scharlakansröd snö Vita ytor med röda accenter. - + Soundtracks Musik Uppspelningsalternativ diff --git a/app/src/main/res/values-th/strings.xml b/app/src/main/res/values-th/strings.xml index fb4139f53b..be1f83c7d4 100644 --- a/app/src/main/res/values-th/strings.xml +++ b/app/src/main/res/values-th/strings.xml @@ -9,15 +9,35 @@ DroidDeck รีสตาร์ทโดยอัตโนมัติไม่ได้ ปิดแอปให้สนิทแล้วเปิดใหม่อีกครั้ง DroidDeck - การเริ่มใช้งานครั้งแรกจะดาวน์โหลด Steam ซึ่งอาจใช้เวลาสักครู่ - ตามค่าเริ่มต้น การออกจากแอปจะหยุด Steam ไว้ชั่วคราว แล้วกลับมาทำงานต่อจากจุดเดิมเมื่อคุณเปิดแอปอีกครั้ง - คอนโทรลเลอร์ของคุณจะปรากฏเป็นจอย Xbox 360 หากไม่เช่นนั้นให้ใช้ปุ่มควบคุมบนหน้าจอ + การเปิดใช้งานครั้งแรกจะดาวน์โหลด Steam ซึ่งอาจใช้เวลาสักครู่ + คอนโทรลเลอร์ของคุณจะปรากฏใน Steam เป็นคอนโทรลเลอร์ Steam Deck สลับเป็น Steam Controller, DualShock 4, DualSense หรือ Xbox 360 ได้ในการตั้งค่าเซสชัน โดยจะมีผลในเซสชันถัดไป + กดค้างปุ่มย้อนกลับบนคอนโทรลเลอร์เพื่อเปิดเมนู Quick Access ของ Steam ต้องเปิด "กดค้างย้อนกลับสำหรับทางลัด Steam" ในการตั้งค่าเซสชันไว้ก่อน + การทำงานในพื้นหลังกำหนดสิ่งที่เกิดขึ้นเมื่อคุณออกจากแอป: ดั้งเดิมจะเตรียม Steam เข้าสู่โหมดพัก อัตโนมัติจะหยุดชั่วคราว กำหนดเองจะรอให้กดดำเนินการต่อ ไม่เลยจะให้ทำงานต่อไป + เกม Steam ใช้จำกัดเฟรมของ Steam ใน Quick Access จอแสดงผลจะสลับไปใช้อัตรารีเฟรชที่หารค่าที่จำกัดลงตัวเมื่อมี + โหมดหน่วงเวลาต่ำในเมนูเซสชันจะส่งอินพุตคอนโทรลเลอร์ที่ 1000 Hz แทน 250 Hz โดยใช้ CPU และแบตเตอรี่เพิ่มขึ้นเล็กน้อย + แต่ละเกมมีโปรไฟล์ของตัวเอง พร้อม Proton, FEX, คอมโพเนนต์ และการตั้งค่าสภาพแวดล้อม + เมนูเซสชันมีสวิตช์ไมโครโฟนสำหรับแชตเสียง และปุ่มหยุดชั่วคราวตอนนี้เพื่อสั่งหยุดเซสชันได้ทันที + ลาก HUD ของ DroidDeck เพื่อย้าย บีบนิ้วเพื่อปรับขนาด และดันไปชิดขอบเพื่อพักเป็นแท็บ FPS เล็ก ๆ + บนเครื่องเกมพกพาแบบสองหน้าจอ หน้าจอล่างสามารถแสดงการดาวน์โหลด การแจ้งเตือน ภาพหน้าจอ และแชต Steam ได้ สลับหน้าจอ จะย้ายเกมไปแสดงที่หน้าจอล่างแทน + เพิ่มคลังเกม Steam จากการ์ด SD ไดรฟ์ USB หรือ SSD แล้ว DroidDeck จะรวมเกมไว้ด้วยกันใน ไลบรารี ของคุณ + สโตร์ ให้คุณลงชื่อเข้าใช้ Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io และ Game Jolt แล้วติดตั้งและอัปเดตเกมของสโตร์เหล่านั้นจาก DroidDeck ได้ + คอมโพเนนต์อย่าง FEX, DXVK และ VKD3D-Proton อัปเดตตัวเอง และค่าเริ่มต้นคือ Proton Experimental ARM64 หรือ Proton 11.0 ARM64 เมื่อติดตั้งบิลด์นั้นแล้ว + บีบอัด Steam ขณะเล่นเกม ช่วยเพิ่ม RAM ว่างบนอุปกรณ์ที่หน่วยความจำเหลือน้อย + ปัดเข้าจากขอบขวาเพื่อเปิดเมนูเซสชัน: โหมดทัชแพด แป้นพิมพ์พีซี โหมดหน่วงเวลาต่ำ โปรไฟล์เกม และอื่น ๆ + เกมช้าใช่ไหม ลองจำกัดเฟรมเรตใน Quick Access แล้วลองใช้ Proton เวอร์ชันอื่นหรือพรีเซ็ต FEX อื่นในคอมโพเนนต์ของเกม + เสียงเกมแตกพร่าหรือไม่มีเสียง ลองเปิดสวิตช์ DirectAudio สำหรับเกม ในการตั้งค่า Steam ภายใต้ เสียง + การตั้งค่า แล้วไปที่ พื้นที่จัดเก็บ สามารถล้างแคชเชเดอร์และเพรฟิกซ์ที่ตกค้างจากเกมที่คุณลบออกได้ + เจอข้อผิดพลาดใช่ไหม แชร์ล็อก ในเมนูเซสชันจะรวบรวมข้อมูลวินิจฉัย โพสต์ได้ที่ #bug-reports บน Discord - การเริ่มใช้งานครั้งแรกจะตั้งค่าเดสก์ท็อป ซึ่งอาจใช้เวลาสักครู่ - ตามค่าเริ่มต้น การออกจากแอปจะหยุดเซสชันไว้ชั่วคราว แล้วกลับมาทำงานต่อจากจุดเดิมเมื่อคุณเปิดแอปอีกครั้ง - การสัมผัสหน้าจอทำงานเหมือนทัชแพด ลากเพื่อเลื่อนตัวชี้ แตะเพื่อคลิก - คอนโทรลเลอร์ของคุณจะปรากฏเป็นจอย Xbox 360 หากไม่เช่นนั้นให้ใช้ปุ่มควบคุมบนหน้าจอ + การเปิดใช้งานครั้งแรกจะตั้งค่าเดสก์ท็อป ซึ่งอาจใช้เวลาสักครู่ + การสัมผัสทำงานเหมือนทัชแพด: ลากเพื่อเลื่อนตัวชี้ แตะเพื่อคลิก + การทำงานในพื้นหลังกำหนดสิ่งที่เกิดขึ้นเมื่อคุณออกจากแอป: กำหนดเองจะรอให้กดดำเนินการต่อเป็นค่าเริ่มต้น อัตโนมัติจะหยุดชั่วคราว ไม่เลยจะให้ทำงานต่อไป + ปัดเข้าจากขอบขวาเพื่อเปิดเมนูเซสชัน แล้วเลือก แป้นพิมพ์พีซี เพื่อพิมพ์ในแอปที่ไม่รับแป้นพิมพ์ของ Android + แป้นพิมพ์พีซีในเมนูเซสชันปรับขนาด ความโปร่งใส และกลุ่มปุ่มได้ + คอนโทรลเลอร์ของคุณจะปรากฏเป็นแผงควบคุม Xbox 360 หากไม่เช่นนั้น ให้ใช้ปุ่มควบคุมบนหน้าจอ + เมนูเซสชันมีสวิตช์ไมโครโฟนและปุ่มหยุดชั่วคราวตอนนี้เพื่อสั่งหยุดเซสชันได้ทันที + เจอข้อผิดพลาดใช่ไหม แชร์ล็อก ในเมนูเซสชันจะรวบรวมข้อมูลวินิจฉัย โพสต์ได้ที่ #bug-reports บน Discord เซสชัน แสดงขณะมีเซสชัน Steam หรือเดสก์ท็อปเปิดอยู่ @@ -269,6 +289,10 @@ ทัชแพด โดยตรง อัตโนมัติ: ทัชแพดในเดสก์ท็อป โดยตรงใน Steam + ปากกา + เมาส์ + การสัมผัส + ปุ่มด้านข้าง ปุ่มควบคุมบนหน้าจอ Steam + QAM อัตโนมัติจะแสดงปุ่มควบคุมเมื่อไม่มีคอนโทรลเลอร์เชื่อมต่ออยู่ @@ -602,6 +626,8 @@ ปิด ค่าเริ่มต้นของไดรเวอร์ บีบอัด Steam ขณะเล่นเกม + บีบอัดหน่วยความจำเกมที่ไม่ได้ใช้งาน + บีบอัดหน่วยความจำเกมที่ไม่ได้ใช้งานเมื่อ RAM เหลือน้อย ปิดไว้หากเกมค้างไม่กี่วินาทีทุกประมาณครึ่งนาที มีผลเมื่อเริ่มเซสชันครั้งถัดไป 20 วินาทีหลังเกมเริ่ม ไคลเอนต์ Steam จะถูกบีบอัดลงใน zRAM เพื่อเหลือหน่วยความจำให้เกมมากขึ้น และอ่านกลับเมื่อปิดเกม ปิดตัวเลือกนี้หากเซสชันปิดไปไม่นานหลังเริ่มเกม ขีดจำกัด RAM ด้านบนยังคงบีบอัด Steam เมื่อเซสชันใช้เกินขีดจำกัด ขีดจำกัด RAM มีผลขณะไคลเอนต์ Steam ทำงาน ทั้งในโหมด Steam หรือจากเดสก์ท็อป เมื่อเซสชันใช้เกินค่านี้ Steam และโปรเซสอื่นที่รองรับของเซสชันจะถูกบีบอัดลงใน zRAM ตามลำดับ เป็นขีดจำกัดแบบอ่อน: ไม่มีอะไรถูกปิด แต่เกมอาจกระตุกขณะดึงหน้าหน่วยความจำกลับมา @@ -612,7 +638,7 @@ สำหรับ Adreno เท่านั้น สะดุดน้อยลง แต่ใช้แบตเตอรี่และเกิดความร้อนมากขึ้น การแก้ไขเซสชัน Turnip: การเรนเดอร์ sysmem - เร็วขึ้นสำหรับไคลเอนต์ Steam ในเกมไดรเวอร์จะเลือกการเรนเดอร์แบบไทล์หรือในหน่วยความจำระบบในแต่ละพาส จำเป็นสำหรับ Adreno 710/720/722 + ใช้กับไคลเอนต์ Steam และเกม จำเป็นสำหรับ Adreno 710/720/722 ข้ามตัวช่วย xalia ของ Steam droiddeck-ntsync ตัวแทนในระดับยูสเซอร์สเปซของไดรเวอร์ ntsync ของ Linux เมื่อเปิดใช้ Proton จะใช้สิ่งนี้แทน droiddeck-esync และ droiddeck-fsync ใช้ได้กับ Proton Experimental ARM64, GE-Proton และ proton-cachyos จะมีผลในเซสชันถัดไป @@ -1816,6 +1842,7 @@ %1$s ✓ Ctrl+C Ctrl+D + ล้าง ติดตั้งรันไทม์ก่อน ไลบรารี Steam ไม่พร้อมใช้งาน ไลบรารี SD ก่อนหน้าไม่พร้อมใช้งาน @@ -3808,8 +3835,6 @@ Alt+Tab ปุ่ม Win และปุ่มโฮมทำงานในเซสชัน เป็นสีเทาใน Android? ข้อมูลแอป → ⋮ → อนุญาตการตั้งค่าที่จำกัด ถูกบล็อกโดย Android · ข้อมูลแอป → ⋮ → อนุญาตการตั้งค่าที่จำกัด - ปุ่มระบบของ DroidDeck - ให้ Alt+Tab ปุ่ม Win และปุ่มโฮมทำงานในเซสชัน DroidDeck ที่ใช้งานอยู่แทน Android เปิดความสว่างในการตั้งค่า → การผสานรวม Steam บริดจ์ Mali: ปิด %1$s ใช้บริดจ์ Mali ไม่ได้ (ต้องการ GPU Mali ที่ยังไม่มีเส้นทางไดรเวอร์ระบบ) สวิตช์นี้จึงไม่มีผลบนเครื่องนี้ @@ -3969,10 +3994,11 @@ รีเซ็ตตำแหน่ง แสดงป้ายกำกับ ไม่สามารถนำเข้าการจัดวางนี้ได้ + ติดตั้งผ่าน %1$s หิมะสีแดงชาด พื้นผิวสีขาวมีสีแดงเป็นสีเน้น - + ซาวด์แทร็ก เพลง ตัวเลือกการเล่น diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml index 9623e13648..34d1082486 100644 --- a/app/src/main/res/values-tr/strings.xml +++ b/app/src/main/res/values-tr/strings.xml @@ -9,15 +9,35 @@ DroidDeck otomatik olarak yeniden başlatılamadı. Uygulamayı tamamen kapatıp yeniden açın. DroidDeck - İlk çalıştırmada Steam indirilir. Bu işlem birkaç dakika sürebilir. - Varsayılan olarak uygulamadan çıkınca Steam duraklatılır; geri döndüğünüzde kaldığı yerden devam eder. - Kumandanız Xbox 360 kumandası olarak görünür. Kumanda yoksa ekran üstü kontrolleri kullanın. + İlk çalıştırmada Steam indirilir. Bu birkaç dakika sürebilir. + Kumandan Steam\'e Steam Deck kumandası olarak görünür. Oturum ayarlarından Steam Controller, DualShock 4, DualSense veya Xbox 360 kumandasına geçebilirsin; bir sonraki oturumda geçerli olur. + Steam\'in Hızlı erişim menüsünü açmak için kumandada Geri\'yi basılı tut. Oturum ayarlarında "Steam kısayolları için Geri\'yi basılı tut" açık olmalı. + Arka plan davranışı, uygulamadan çıkınca ne olacağını belirler: Yerel Steam\'i uykuya hazırlar, Otomatik duraklatır, Manuel Devam et\'i bekler, Asla çalışmaya devam ettirir. + Steam oyunları Hızlı erişim\'deki Steam Kare sınırı ayarını kullanır. Sınırın tam bölündüğü bir yenileme hızı varsa ekran ona geçer. + Oturum menüsündeki Düşük gecikme modu, kumanda girişini 250 Hz yerine 1000 Hz ile gönderir; karşılığında biraz daha CPU ve pil harcar. + Her oyunun Proton, FEX, bileşenler ve ortam ayarlarını içeren kendi profili vardır. + Oturum menüsünde sesli sohbet için bir mikrofon düğmesi ve oturumu istediğin an dondurmak için Şimdi askıya al düğmesi bulunur. + DroidDeck HUD\'unu taşımak için sürükle, boyutlandırmak için iki parmakla yakınlaştır ve küçük bir FPS sekmesi olarak yuvalamak için kenara doğru it. + Çift ekranlı el konsollarında alt ekran indirmeleri, bildirimleri, ekran görüntülerini ve Steam sohbetini gösterebilir. Ekranları değiştir oyunu bunun yerine alta koyar. + SD karttan, USB sürücüden veya SSD\'den Steam kütüphaneleri ekle; DroidDeck oyunları Kütüphane\'nde bir arada tutar. + Mağazalar, Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io ve Game Jolt\'ta oturum açmanı, ardından oyunlarını DroidDeck\'ten yüklemeni ve güncellemeni sağlar. + FEX, DXVK ve VKD3D-Proton gibi bileşenler kendini günceller; varsayılan Proton Experimental ARM64\'tür, Proton 11.0 ARM64 kurulduktan sonra ise o olur. + Oyun çalışırken Steam\'i sıkıştır, belleği az olan cihazlarda RAM boşaltır. + Oturum menüsünü açmak için sağ kenardan içeri kaydır: dokunmatik yüzey modu, PC klavyesi, düşük gecikme, oyun profili ve daha fazlası. + Oyun yavaş mı çalışıyor? Hızlı erişim\'de kare hızını sınırla, sonra oyunun bileşenlerinde başka bir Proton sürümü veya FEX ön ayarı dene. + Oyun sesinde cızırtı var ya da ses yok mu? Steam ayarlarında Ses altındaki Oyunlar için DirectAudio düğmesini dene. + Kurulum, ardından Depolama, kaldırdığın oyunlardan kalan gölgelendirici önbelleklerini ve artakalan önekleri temizleyebilir. + Bir hata mı buldun? Oturum menüsündeki Günlükleri paylaş tanılama bilgilerini paketler. Bunları Discord\'da #bug-reports kanalına gönder. - İlk çalıştırmada masaüstü kurulur. Bu işlem birkaç dakika sürebilir. - Varsayılan olarak uygulamadan çıkınca oturum duraklatılır; geri döndüğünüzde kaldığı yerden devam eder. - Dokunma, dokunmatik yüzey gibi çalışır: işaretçiyi taşımak için sürükleyin, tıklamak için dokunun. - Kumandanız Xbox 360 kumandası olarak görünür. Kumanda yoksa ekran üstü kontrolleri kullanın. + İlk çalıştırmada masaüstü kurulur. Bu birkaç dakika sürebilir. + Dokunma, dokunmatik yüzey gibi çalışır: imleci taşımak için sürükle, tıklamak için dokun. + Arka plan davranışı, uygulamadan çıkınca ne olacağını belirler: Manuel varsayılan olarak Devam et\'i bekler, Otomatik duraklatır, Asla çalışmaya devam ettirir. + Oturum menüsünü açmak için sağ kenardan içeri kaydır, ardından Android klavyesini yok sayan uygulamalarda yazmak için PC klavyesi\'ni seç. + Oturum menüsündeki PC klavyesinin boyutu, opaklığı ve tuş grupları ayarlanabilir. + Kumandan Xbox 360 kumandası olarak görünür. Yoksa ekrandaki kontrolleri kullan. + Oturum menüsünde bir mikrofon düğmesi ve oturumu istediğin an dondurmak için Şimdi askıya al düğmesi bulunur. + Bir hata mı buldun? Oturum menüsündeki Günlükleri paylaş tanılama bilgilerini paketler. Bunları Discord\'da #bug-reports kanalına gönder. Oturum Steam veya masaüstü oturumu açıkken gösterilir @@ -269,6 +289,10 @@ Dokunmatik yüzey Doğrudan Otomatik: Masaüstünde dokunmatik yüzey, Steam\'de doğrudan. + Kalem + Fare + Dokunma + Yan düğme Ekran üstü kontroller Steam + QAM Otomatik, kumanda bağlı değilken kontrolleri gösterir. @@ -604,6 +628,8 @@ Kapalı Sürücü varsayılanı Oyun çalışırken Steam\'i sıkıştır + Oyunun boşta belleğini sıkıştır + RAM azaldığında oyunun boşta belleğini sıkıştırır. Oyunlar yaklaşık her yarım dakikada birkaç saniye donuyorsa kapatın. Oturum bir sonraki başlatıldığında geçerli olur. Oyun başladıktan 20 sn sonra oyuna daha fazla bellek kalması için Steam istemcisi zRAM\'e sıkıştırılır ve oyun kapanınca geri okunur. Oyunlar başladıktan kısa süre sonra oturum kapanıyorsa bunu kapatın. Yukarıdaki RAM sınırı, oturum onu aştığında Steam\'i yine sıkıştırır. RAM sınırı Steam istemcisi Steam oturumunda veya masaüstünden çalışırken uygulanır. Oturum bundan fazlasını kullandığında önce Steam, ardından oturumun desteklenen diğer işlemleri zRAM\'e sıkıştırılır. Yumuşak bir sınırdır: hiçbir şey kapatılmaz, ancak sayfalar geri yüklenirken oyunlar takılabilir. @@ -614,7 +640,7 @@ Yalnızca Adreno. Daha az takılma, daha fazla pil tüketimi ve ısınma. Oturum düzeltmeleri Turnip: sysmem işleme - Steam istemcisi için daha hızlı; oyunlarda sürücü her geçişte döşeme tabanlı veya sistem belleğinde işlemeyi seçer. Adreno 710/720/722\'de gereklidir. + Steam istemcisi ve oyunlar için geçerlidir. Adreno 710/720/722\'de gereklidir. Steam\'in xalia yardımcısını atla droiddeck-ntsync Linux ntsync sürücüsünün kullanıcı alanında çalışan bir yedeği. Açıkken Proton, droiddeck-esync ve droiddeck-fsync yerine bunu kullanır. Proton Experimental ARM64, GE-Proton ve proton-cachyos ile çalışır. Sonraki oturumda uygulanır. @@ -1826,6 +1852,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Temizle Önce çalışma ortamını yükleyin Steam kütüphanesi kullanılamıyor Önceki SD kütüphanesi kullanılamıyor @@ -3837,8 +3864,6 @@ Alt+Tab, Win tuşu ve Ana Ekran düğmesi oturumda kalır Android\'de gri mi görünüyor? Uygulama bilgileri → ⋮ → Kısıtlanmış ayarlara izin ver Android tarafından engellendi · Uygulama bilgileri → ⋮ → Kısıtlanmış ayarlara izin ver - DroidDeck sistem tuşları - Alt+Tab, Win tuşu ve Ana Ekran düğmesini Android yerine etkin DroidDeck oturumunda tutar. Kurulum → Steam entegrasyonu bölümünde Parlaklık\'ı açın Mali köprüsü: kapalı %1$s Mali köprüsünü kullanamaz (sistem sürücüsü yolu olmayan bir Mali GPU gerekir), bu yüzden bu anahtarın burada etkisi yok. @@ -3999,10 +4024,11 @@ Konumları sıfırla Etiketi göster Bu düzen içe aktarılamadı + %1$s üzerinden yüklenir Kızıl Kar Kırmızı vurgulu beyaz yüzeyler. - + Oyun müzikleri Müzik Oynatma seçenekleri diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 15ab8c9c4d..924f1ddf79 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -9,15 +9,35 @@ DroidDeck не вдалося перезапуститися автоматично. Повністю закрийте додаток, а потім відкрийте його знову. DroidDeck - Під час першого запуску завантажується Steam. Це може зайняти кілька хвилин. - За замовчуванням вихід із додатка ставить Steam на паузу; коли ви повернетеся, усе продовжиться з того самого місця. - Ваш контролер відображається як геймпад Xbox 360. Якщо контролера немає, скористайтеся екранним керуванням. + Під час першого запуску завантажується Steam. Це може тривати кілька хвилин. + Для Steam ваш контролер виглядає як контролер Steam Deck. У налаштуваннях сеансу його можна перемкнути на Steam Controller, DualShock 4, DualSense або Xbox 360; зміна діє з наступного сеансу. + Утримуйте «Назад» на контролері, щоб відкрити меню «Швидкий доступ» у Steam. У налаштуваннях сеансу має бути ввімкнено «Утримання «Назад» для комбінацій Steam». + «Робота у фоні» визначає, що станеться, коли ви залишите додаток: «Нативний» готує Steam до сну, «Авто» призупиняє його, «Вручну» чекає на «Відновити», «Ніколи» залишає його працювати. + Ігри Steam використовують «Обмеження кадрів» Steam у меню «Швидкий доступ». Якщо є частота оновлення, на яку обмеження ділиться націло, екран перемикається на неї. + «Режим низької затримки» в меню сеансу надсилає введення з контролера з частотою 1000 Гц замість 250 Гц, за трохи більше навантаження на CPU й акумулятор. + Кожна гра має власний профіль із Proton, FEX, компонентами та налаштуваннями середовища. + У меню сеансу є перемикач мікрофона для голосового чату та кнопка «Призупинити зараз», щоб заморозити сеанс будь-коли. + Перетягніть HUD DroidDeck, щоб перемістити його, зведіть пальці, щоб змінити розмір, а щоб закріпити його як невелику вкладку FPS, відсуньте його до краю. + На портативних пристроях із двома екранами нижній екран може показувати завантаження, сповіщення, знімки екрана та чат Steam. «Поміняти екрани» натомість переносить гру на нижній екран. + Додавайте бібліотеки Steam із SD-картки, USB-накопичувача чи SSD, і DroidDeck збере ігри разом у вашій «Бібліотеці». + «Магазини» дають змогу увійти в Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io і Game Jolt, а потім установлювати й оновлювати їхні ігри з DroidDeck. + Компоненти, як-от FEX, DXVK і VKD3D-Proton, оновлюються самі, а типовою є Proton Experimental ARM64 або Proton 11.0 ARM64, щойно цю збірку встановлено. + «Стискати Steam під час гри» звільняє оперативну пам\'ять на пристроях, яким її бракує. + Проведіть від правого краю, щоб відкрити меню сеансу: режим сенсорної панелі, «Клавіатура ПК», низька затримка, профіль гри та інше. + Гра гальмує? Обмежте частоту кадрів у меню «Швидкий доступ», потім спробуйте іншу версію Proton або набір налаштувань FEX у компонентах гри. + Тріск або зникає звук у грі? Спробуйте перемикач «DirectAudio для ігор» у налаштуваннях Steam у розділі «Звук». + «Налаштування», а потім «Сховище» можуть очистити кеші шейдерів і залишені префікси від видалених ігор. + Натрапили на помилку? «Поділитися журналами» в меню сеансу збирає діагностику. Опублікуйте їх у #bug-reports на Discord. - Під час першого запуску налаштовується робочий стіл. Це може зайняти кілька хвилин. - За замовчуванням вихід із додатка ставить сеанс на паузу; коли ви повернетеся, усе продовжиться з того самого місця. - Екран працює як сенсорна панель: проводьте пальцем, щоб рухати вказівник, і торкайтеся, щоб клацнути. - Ваш контролер відображається як геймпад Xbox 360. Якщо контролера немає, скористайтеся екранним керуванням. + Під час першого запуску налаштовується робочий стіл. Це може тривати кілька хвилин. + Дотик працює як сенсорна панель: проведіть, щоб перемістити вказівник, торкніться, щоб клацнути. + «Робота у фоні» визначає, що станеться, коли ви залишите додаток: «Вручну» за замовчуванням чекає на «Відновити», «Авто» призупиняє, «Ніколи» залишає працювати. + Проведіть від правого краю, щоб відкрити меню сеансу, а потім виберіть «Клавіатура ПК», щоб вводити текст у додатках, які ігнорують клавіатуру Android. + «Клавіатура ПК» в меню сеансу має регульований розмір, непрозорість і групи клавіш. + Ваш контролер виглядає як геймпад Xbox 360. Інакше користуйтеся елементами керування на екрані. + У меню сеансу є перемикач мікрофона та кнопка «Призупинити зараз», щоб заморозити сеанс будь-коли. + Натрапили на помилку? «Поділитися журналами» в меню сеансу збирає діагностику. Опублікуйте їх у #bug-reports на Discord. Сеанс Відображається, поки відкрито сеанс Steam або робочого столу @@ -269,6 +289,10 @@ Сенсорна панель Пряме «Авто»: сенсорна панель на робочому столі, пряме введення в Steam. + Перо + Миша + Сенсорне введення + Бічна кнопка Екранне керування Steam + QAM «Авто» показує екранне керування, коли контролер не під’єднано. @@ -608,6 +632,8 @@ Вимк. Типово для драйвера Стискати Steam під час гри + Стискати неактивну пам’ять гри + Стискає неактивну пам’ять гри, коли мало RAM. Вимкніть, якщо ігри зависають на кілька секунд приблизно кожні пів хвилини. Застосовується під час наступного запуску сеансу. Через 20 с після запуску гри клієнт Steam стискається в zRAM, щоб залишити грі більше памʼяті, і зчитується назад, коли гра закривається. Вимкніть, якщо сеанс закривається невдовзі після запуску ігор. Ліміт RAM вище все одно стискає Steam, коли сеанс його перевищує. Ліміт RAM Діє, поки працює клієнт Steam, у режимі Steam або з робочого столу. Коли сеанс використовує більше цього значення, Steam, а потім інші підтримувані процеси сеансу стискаються в zRAM. Мʼякий ліміт: нічого не закривається, але ігри можуть підвисати, поки сторінки повертаються. @@ -618,7 +644,7 @@ Лише Adreno. Менше запинок, вища витрата заряду та нагрів. Виправлення сеансу Turnip: рендеринг через sysmem - Швидше для клієнта Steam; в іграх драйвер для кожного проходу вибирає тайловий рендеринг або рендеринг у системній пам’яті. Потрібно для Adreno 710/720/722. + Застосовується до клієнта Steam та ігор. Потрібно для Adreno 710/720/722. Пропускати помічник Steam xalia droiddeck-ntsync Програмна заміна драйвера ntsync ядра Linux у просторі користувача. Поки це увімкнено, Proton використовує її замість droiddeck-esync і droiddeck-fsync. Працює з Proton Experimental ARM64, GE-Proton і proton-cachyos. Застосовується в наступному сеансі. @@ -1872,6 +1898,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Очистити Спершу встановіть середовище Бібліотека Steam недоступна Попередня бібліотека на SD-карті недоступна @@ -3915,8 +3942,6 @@ Alt+Tab, клавіша Win і кнопка «Додому» працюють у сеансі Неактивно в Android? «Про додаток» → ⋮ → «Дозволити обмежені налаштування» Заблоковано Android · «Про додаток» → ⋮ → «Дозволити обмежені налаштування» - Системні клавіші DroidDeck - Залишає Alt+Tab, клавішу Win і кнопку «Додому» в активному сеансі DroidDeck, а не в Android. Увімкніть «Яскравість» у «Налаштування → Інтеграція зі Steam» Міст Mali: вимк. %1$s не може використовувати міст Mali (для цього потрібен GPU Mali без маршруту через системний драйвер), тому цей перемикач тут не діє. @@ -4079,10 +4104,11 @@ Скинути розташування Показувати підпис Не вдалося імпортувати цю розкладку + Встановлюється через %1$s Багряний сніг Білі поверхні з червоними акцентами. - + Саундтреки Музика Параметри відтворення diff --git a/app/src/main/res/values-vi/strings.xml b/app/src/main/res/values-vi/strings.xml index f133ef3d94..a8532cdbad 100644 --- a/app/src/main/res/values-vi/strings.xml +++ b/app/src/main/res/values-vi/strings.xml @@ -9,15 +9,35 @@ DroidDeck không thể tự khởi động lại. Hãy đóng hẳn ứng dụng rồi mở lại. DroidDeck - Lần chạy đầu tải Steam. Quá trình này có thể mất vài phút. - Theo mặc định, rời khỏi ứng dụng sẽ tạm dừng Steam; nó tiếp tục từ nơi bạn dừng lại khi bạn quay lại. - Tay cầm của bạn hiện ra như tay cầm Xbox 360. Nếu không, hãy dùng các nút điều khiển trên màn hình. + Lần chạy đầu tiên sẽ tải Steam. Việc này có thể mất vài phút. + Tay cầm của bạn hiện với Steam như tay cầm Steam Deck. Hãy chuyển sang tay cầm Steam Controller, DualShock 4, DualSense hoặc Xbox 360 trong cài đặt phiên; thay đổi áp dụng từ phiên sau. + Giữ Quay lại trên tay cầm để mở menu Truy cập nhanh của Steam. Phải bật "Giữ Quay lại cho phím tắt Steam" trong cài đặt phiên. + Hành vi khi ở nền quyết định điều gì xảy ra khi bạn rời ứng dụng: Gốc chuẩn bị Steam để ngủ, Tự động tạm dừng nó, Thủ công chờ Tiếp tục, Không bao giờ giữ nó luôn chạy. + Game Steam dùng Giới hạn khung hình của Steam trong Truy cập nhanh. Màn hình chuyển sang tần số quét mà mức giới hạn chia hết khi có. + Chế độ độ trễ thấp trong menu phiên gửi đầu vào tay cầm ở 1000 Hz thay vì 250 Hz, đổi lại tốn thêm một chút CPU và pin. + Mỗi game có hồ sơ riêng với Proton, FEX, các thành phần và cài đặt môi trường. + Menu phiên có nút bật/tắt micro cho chat thoại và nút Tạm dừng ngay để đóng băng phiên khi cần. + Kéo HUD của DroidDeck để di chuyển, chụm hai ngón để đổi kích thước, và đẩy nó ra mép để thu gọn thành một tab FPS nhỏ. + Trên máy cầm tay hai màn hình, màn hình dưới có thể hiển thị tải xuống, thông báo, ảnh chụp màn hình và chat Steam. Hoán đổi màn hình sẽ đặt game xuống đó thay thế. + Thêm thư viện Steam từ thẻ SD, ổ USB hoặc SSD, và DroidDeck sẽ gom các game lại trong Thư viện của bạn. + Cửa hàng cho phép bạn đăng nhập Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io và Game Jolt, rồi cài đặt và cập nhật game của họ ngay từ DroidDeck. + Các thành phần như FEX, DXVK và VKD3D-Proton tự cập nhật, và mặc định là Proton Experimental ARM64, hoặc Proton 11.0 ARM64 khi bản dựng đó đã được cài. + Nén Steam khi game đang chạy giúp giải phóng RAM trên các thiết bị thiếu bộ nhớ. + Vuốt vào từ mép phải để mở menu phiên: chế độ bàn di chuột, Bàn phím PC, độ trễ thấp, hồ sơ game và nhiều hơn nữa. + Game chạy chậm? Hãy giới hạn tốc độ khung hình trong Truy cập nhanh, rồi thử phiên bản Proton khác hoặc bộ cài đặt sẵn FEX khác trong các thành phần của game. + Âm thanh game bị rè hoặc mất tiếng? Hãy thử bật DirectAudio cho game trong cài đặt Steam, mục Âm thanh. + Thiết lập, rồi Lưu trữ, có thể xóa bộ nhớ đệm trình đổ bóng và tiền tố còn sót lại của các game bạn đã gỡ. + Gặp lỗi? Chia sẻ log trong menu phiên sẽ gói gọn dữ liệu chẩn đoán. Hãy đăng chúng trong #bug-reports trên Discord. - Lần chạy đầu thiết lập desktop. Quá trình này có thể mất vài phút. - Theo mặc định, rời khỏi ứng dụng sẽ tạm dừng phiên; nó tiếp tục từ nơi bạn dừng lại khi bạn quay lại. - Chạm hoạt động như touchpad: kéo để di chuyển con trỏ, chạm để nhấp. - Tay cầm của bạn hiện ra như tay cầm Xbox 360. Nếu không, hãy dùng các nút điều khiển trên màn hình. + Lần chạy đầu tiên sẽ thiết lập máy tính để bàn. Việc này có thể mất vài phút. + Cảm ứng hoạt động như bàn di chuột: kéo để di chuyển con trỏ, chạm để nhấp. + Hành vi khi ở nền quyết định điều gì xảy ra khi bạn rời ứng dụng: Thủ công mặc định chờ Tiếp tục, Tự động tạm dừng, Không bao giờ giữ nó luôn chạy. + Vuốt vào từ mép phải để mở menu phiên, rồi chọn Bàn phím PC để gõ trong các ứng dụng bỏ qua bàn phím Android. + Bàn phím PC trong menu phiên có thể điều chỉnh kích thước, độ mờ và nhóm phím. + Tay cầm của bạn hiện là tay cầm Xbox 360. Nếu không, hãy dùng các nút điều khiển trên màn hình. + Menu phiên có nút bật/tắt micro và nút Tạm dừng ngay để đóng băng phiên khi cần. + Gặp lỗi? Chia sẻ log trong menu phiên sẽ gói gọn dữ liệu chẩn đoán. Hãy đăng chúng trong #bug-reports trên Discord. Phiên Hiển thị khi có phiên Steam hoặc desktop đang mở @@ -269,6 +289,10 @@ Touchpad Trực tiếp Tự động: touchpad ở Desktop, trực tiếp ở Steam. + Bút + Chuột + Chạm + Nút bên Điều khiển trên màn hình Steam + QAM Tự động hiện các nút điều khiển khi không có tay cầm kết nối. @@ -602,6 +626,8 @@ Tắt Mặc định của driver Nén Steam khi game đang chạy + Nén bộ nhớ game không hoạt động + Nén bộ nhớ game không hoạt động khi RAM thấp. Tắt nếu game bị đứng vài giây khoảng mỗi nửa phút. Áp dụng từ lần khởi động phiên tiếp theo. 20 giây sau khi game bắt đầu, client Steam được nén vào zRAM để game có thêm bộ nhớ, và được đọc lại khi game đóng. Tắt nếu phiên bị đóng ngay sau khi game bắt đầu. Giới hạn RAM ở trên vẫn nén Steam khi phiên vượt quá mức đó. Giới hạn RAM Áp dụng khi client Steam đang chạy, ở chế độ Steam hoặc từ desktop. Khi phiên dùng nhiều hơn mức này, Steam rồi đến các tiến trình được hỗ trợ khác của phiên sẽ bị nén vào zRAM. Giới hạn mềm: không có gì bị đóng, nhưng game có thể giật khi các trang được nạp lại. @@ -612,7 +638,7 @@ Chỉ dành cho Adreno. Ít giật hơn, dùng nhiều pin và nhiệt hơn. Các bản sửa phiên Turnip: render sysmem - Nhanh hơn cho ứng dụng Steam; trong game, trình điều khiển chọn kết xuất theo ô hoặc trong bộ nhớ hệ thống cho từng lượt. Bắt buộc trên Adreno 710/720/722. + Áp dụng cho ứng dụng Steam và trò chơi. Bắt buộc trên Adreno 710/720/722. Bỏ qua trình trợ giúp xalia của Steam droiddeck-ntsync Một bản thay thế ở không gian người dùng cho driver ntsync của Linux. Khi đang bật, Proton dùng nó thay cho droiddeck-esync và droiddeck-fsync. Hoạt động với Proton Experimental ARM64, GE-Proton và proton-cachyos. Áp dụng từ phiên sau. @@ -1816,6 +1842,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Xóa Cài runtime trước Thư viện Steam không khả dụng Thư viện SD trước đó không khả dụng @@ -3808,8 +3835,6 @@ Alt+Tab, phím Win và nút Trang chủ giữ trong phiên Bị làm mờ trong Android? Thông tin ứng dụng → ⋮ → Cho phép chế độ cài đặt bị hạn chế Bị Android chặn · Thông tin ứng dụng → ⋮ → Cho phép chế độ cài đặt bị hạn chế - Phím hệ thống DroidDeck - Giữ Alt+Tab, phím Win và nút Trang chủ trong phiên DroidDeck đang dùng thay vì Android. Bật Độ sáng trong Thiết lập → Tích hợp Steam Cầu Mali: tắt %1$s không thể dùng cầu nối Mali (cần GPU Mali không có đường dẫn qua trình điều khiển hệ thống), nên công tắc này không có tác dụng ở đây. @@ -3969,10 +3994,11 @@ Đặt lại vị trí Hiện nhãn Không thể nhập bố cục này + Cài đặt qua %1$s Tuyết đỏ thẫm Bề mặt trắng với điểm nhấn màu đỏ. - + Nhạc nền Nhạc Tùy chọn phát diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 0b5996252e..a063a077e1 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -9,15 +9,35 @@ DroidDeck 无法自动重启。请完全关闭应用,然后重新打开。 DroidDeck - 首次运行会下载 Steam,这可能需要几分钟。 - 默认情况下,离开应用会暂停 Steam;返回后会从原处继续。 - 你的手柄会被识别为 Xbox 360 手柄;若没有手柄,请使用屏幕控制。 + 首次运行会下载 Steam,可能需要几分钟。 + 你的手柄在 Steam 中显示为 Steam Deck 手柄。可在会话设置中切换为 Steam Controller、DualShock 4、DualSense 或 Xbox 360 手柄,下次会话生效。 + 长按手柄上的返回键可打开 Steam 的快捷访问菜单。必须在会话设置中开启“长按返回键使用 Steam 快捷操作”。 + 后台行为决定你离开应用时会发生什么:原生会让 Steam 做好睡眠准备,自动会暂停,手动会等待点按恢复,“从不”则保持运行。 + Steam 游戏使用快捷访问中 Steam 的帧率限制。如果存在能被该上限整除的刷新率,显示器会切换到该刷新率。 + 会话菜单中的低延迟模式会以 1000 Hz 而非 250 Hz 发送手柄输入,代价是略多一点 CPU 和电量消耗。 + 每个游戏都有自己的配置档案,包含 Proton、FEX、组件和环境设置。 + 会话菜单里有用于语音聊天的麦克风开关,以及可随时冻结会话的“立即暂停”按钮。 + 拖动 DroidDeck HUD 可移动它,双指捏合可调整大小,推到屏幕边缘可停靠为小型 FPS 标签。 + 在双屏掌机上,下屏可以显示下载、通知、截图和 Steam 聊天。“交换屏幕”会改为把游戏放到下屏。 + 可添加 SD 卡、USB 驱动器或 SSD 上的 Steam 游戏库,DroidDeck 会把这些游戏集中在你的库中。 + 游戏商店让你登录 Epic Games、GOG、Xbox、EA、Battle.net、Ubisoft Connect、Amazon Games、itch.io 和 Game Jolt,然后在 DroidDeck 中安装和更新它们的游戏。 + FEX、DXVK 和 VKD3D-Proton 等组件会自动更新,默认使用 Proton Experimental ARM64,安装 Proton 11.0 ARM64 后则默认使用它。 + “游戏运行时压缩 Steam”可在内存不足的设备上释放 RAM。 + 从右边缘向内滑动可打开会话菜单:触控板模式、PC 键盘、低延迟、游戏配置档案等。 + 游戏运行缓慢?先在快捷访问中限制帧率,再到游戏的组件中尝试其他 Proton 版本或 FEX 预设。 + 游戏音频爆音或没有声音?请在 Steam 设置的“音频”下尝试“游戏使用 DirectAudio”开关。 + “配置”下的“存储”可以清理已移除游戏留下的着色器缓存和残留前缀。 + 遇到故障?会话菜单中的“分享日志”会打包诊断信息。请发布到 Discord 的 #bug-reports。 - 首次运行会设置桌面环境,这可能需要几分钟。 - 默认情况下,离开应用会暂停会话;返回后会从原处继续。 - 触控区域可当作触控板使用:拖动可移动指针,轻点即可点击。 - 你的手柄会被识别为 Xbox 360 手柄;若没有手柄,请使用屏幕控制。 + 首次运行会设置桌面,可能需要几分钟。 + 触摸的作用类似触控板:拖动可移动指针,轻点即可点击。 + 后台行为决定你离开应用时会发生什么:手动默认会等待点按恢复,自动会暂停,“从不”则保持运行。 + 从右边缘向内滑动可打开会话菜单,然后选择“PC 键盘”,即可在忽略 Android 键盘的应用中输入。 + 会话菜单中的 PC 键盘可调整大小、不透明度和按键分组。 + 你的手柄会显示为 Xbox 360 手柄。否则请使用屏幕上的控件。 + 会话菜单里有麦克风开关和可随时冻结会话的“立即暂停”按钮。 + 遇到故障?会话菜单中的“分享日志”会打包诊断信息。请发布到 Discord 的 #bug-reports。 会话 在 Steam 或桌面会话打开时显示 @@ -269,6 +289,10 @@ 触控板 直接 自动:桌面用触控板,Steam 中用直接触摸。 + 手写笔 + 鼠标 + 触摸 + 侧键 屏幕控制 Steam + QAM 自动模式会在未连接手柄时显示屏幕控制。 @@ -602,6 +626,8 @@ 关闭 驱动默认 游戏运行时压缩 Steam + 压缩游戏闲置内存 + RAM 较低时压缩游戏闲置内存。如果游戏大约每半分钟卡顿几秒,请关闭此项。下次启动会话时生效。 游戏启动 20 秒后,Steam 客户端会被压缩到 zRAM 中,为游戏腾出更多内存,并在游戏关闭时读回。如果会话在游戏启动后不久就关闭,请关闭此选项。设置了上方的 RAM 上限时,会话超出上限后仍会压缩 Steam。 RAM 上限 在 Steam 客户端运行时生效,无论是 Steam 模式还是从桌面启动。会话使用量超过此值时,会先将 Steam、再将会话中其他受支持的进程压缩到 zRAM。这是软上限:不会关闭任何进程,但在页面读回时游戏可能卡顿。 @@ -612,7 +638,7 @@ 仅限 Adreno。卡顿更少,但更耗电、更发热。 会话修复 Turnip:sysmem 渲染 - Steam 客户端更快;游戏中驱动会为每个渲染通道选择分块渲染或系统内存渲染。Adreno 710/720/722 必需。 + 适用于 Steam 客户端和游戏。Adreno 710/720/722 必需。 跳过 Steam 的 xalia 助手 droiddeck-ntsync Linux ntsync 驱动的用户态替代品。开启时,Proton 使用它代替 droiddeck-esync 和 droiddeck-fsync。适用于 Proton Experimental ARM64、GE-Proton 和 proton-cachyos。将在下次会话生效。 @@ -1893,6 +1919,7 @@ %1$s ✓ Ctrl+C Ctrl+D + 清屏 请先安装运行时 Steam 库不可用 之前的 SD 卡库不可用 @@ -3808,8 +3835,6 @@ Alt+Tab、Win 键和主页键留在会话中 在 Android 中显示为灰色?应用信息 → ⋮ → 允许受限设置 已被 Android 阻止 · 应用信息 → ⋮ → 允许受限设置 - DroidDeck 系统按键 - 让 Alt+Tab、Win 键和主页键在当前 DroidDeck 会话中生效,而不是交给 Android。 请在“配置”→“Steam 集成”中开启亮度 DXVK DXVK:自动 @@ -3969,10 +3994,11 @@ 重置位置 显示标签 无法导入此布局 + 通过 %1$s 安装 猩红之雪 白色界面配红色点缀。 - + 原声音乐 音乐 播放选项 diff --git a/app/src/main/res/values-zh-rHK/strings.xml b/app/src/main/res/values-zh-rHK/strings.xml index 709bda78c9..b3752db043 100644 --- a/app/src/main/res/values-zh-rHK/strings.xml +++ b/app/src/main/res/values-zh-rHK/strings.xml @@ -10,14 +10,34 @@ DroidDeck 首次執行會下載 Steam,可能需要幾分鐘。 - 預設情況下,離開應用程式會暫停 Steam;返回時會從上次中斷的地方繼續。 - 你的控制器會顯示為 Xbox 360 控制器。如果沒有控制器,請使用螢幕控制。 + 你的控制器在 Steam 中會顯示為 Steam Deck 控制器。可在工作階段設定中切換為 Steam Controller、DualShock 4、DualSense 或 Xbox 360 控制器,下次工作階段生效。 + 長按控制器上的返回鍵可開啟 Steam 的快速存取選單。必須在工作階段設定中開啟「長按返回鍵使用 Steam 快捷操作」。 + 背景行為決定你離開應用程式時會發生什麼:「原生」會讓 Steam 做好休眠準備,「自動」會暫停,「手動」會等你按「繼續」,「從不」則保持執行。 + Steam 遊戲使用快速存取中 Steam 的幀率限制。如果有能被該上限整除的更新率,顯示器會切換到該更新率。 + 工作階段選單中的低延遲模式會以 1000 Hz 而非 250 Hz 傳送控制器輸入,代價是略多一點 CPU 和電量消耗。 + 每個遊戲都有自己的設定檔,包含 Proton、FEX、元件和環境設定。 + 工作階段選單裡有用於語音聊天的麥克風開關,以及可隨時凍結工作階段的「立即暫停」按鈕。 + 拖曳 DroidDeck HUD 可移動它,雙指捏合可調整大小,推到螢幕邊緣可停靠為小型 FPS 分頁。 + 在雙螢幕掌機上,下方螢幕可以顯示下載、通知、截圖和 Steam 聊天。「交換螢幕」會改為把遊戲放到下方螢幕。 + 可加入 SD 卡、USB 隨身碟或 SSD 上的 Steam 遊戲庫,DroidDeck 會把這些遊戲集中在你的收藏庫中。 + 「商店」讓你登入 Epic Games、GOG、Xbox、EA、Battle.net、Ubisoft Connect、Amazon Games、itch.io 和 Game Jolt,然後在 DroidDeck 中安裝和更新它們的遊戲。 + FEX、DXVK 和 VKD3D-Proton 等元件會自動更新,預設使用 Proton Experimental ARM64,安裝 Proton 11.0 ARM64 後則預設使用它。 + 「遊戲執行時壓縮 Steam」可在記憶體不足的裝置上釋放 RAM。 + 從右邊緣向內滑動可開啟工作階段選單:觸控板模式、電腦鍵盤、低延遲、遊戲設定檔等。 + 遊戲執行緩慢?先在快速存取中限制影格率,再到遊戲的元件中嘗試其他 Proton 版本或 FEX 預設。 + 遊戲音訊爆音或沒有聲音?請在 Steam 設定的「音訊」下嘗試「遊戲使用 DirectAudio」開關。 + 「設定」下的「儲存空間」可以清理已移除遊戲留下的著色器快取和殘留前綴。 + 遇到故障?工作階段選單中的「分享記錄」會打包診斷資訊。請發布到 Discord 的 #bug-reports。 首次執行會設定桌面,可能需要幾分鐘。 - 預設情況下,離開應用程式會暫停會話;返回時會從上次中斷的地方繼續。 - 觸控會當作觸控板使用:拖曳以移動指標,輕按即點擊。 - 你的控制器會顯示為 Xbox 360 控制器。如果沒有控制器,請使用螢幕控制。 + 觸控的作用類似觸控板:拖曳可移動游標,輕點即可點按。 + 背景行為決定你離開應用程式時會發生什麼:「手動」預設會等你按「繼續」,「自動」會暫停,「從不」則保持執行。 + 從右邊緣向內滑動可開啟工作階段選單,然後選擇「電腦鍵盤」,即可在忽略 Android 鍵盤的應用程式中輸入。 + 工作階段選單中的電腦鍵盤可調整大小、不透明度和按鍵群組。 + 你的控制器會顯示為 Xbox 360 控制器。否則請使用螢幕上的控制項。 + 工作階段選單裡有麥克風開關和可隨時凍結工作階段的「立即暫停」按鈕。 + 遇到故障?工作階段選單中的「分享記錄」會打包診斷資訊。請發布到 Discord 的 #bug-reports。 會話 Steam 或桌面會話開啟時顯示 @@ -269,6 +289,10 @@ 觸控板 直接 自動:桌面使用觸控板,Steam 使用直接觸控。 + 觸控筆 + 滑鼠 + 觸控 + 側鍵 螢幕控制 Steam + QAM 「自動」會在未連接控制器時顯示螢幕控制。 @@ -602,6 +626,8 @@ 關閉 驅動程式預設 遊戲執行時壓縮 Steam + 壓縮遊戲閒置記憶體 + RAM 偏低時壓縮遊戲閒置記憶體。如果遊戲大約每半分鐘凍結幾秒,請關閉此項。下次啟動工作階段時生效。 遊戲啟動 20 秒後,Steam 用戶端會被壓縮到 zRAM,為遊戲騰出更多記憶體,並在遊戲關閉時讀回。如果會話在遊戲啟動後不久就關閉,請關閉此選項。若超過上方的 RAM 上限,會話仍會壓縮 Steam。 RAM 上限 在 Steam 用戶端執行時生效,無論是 Steam 模式或從桌面啟動。當會話的用量超過此值時,會先將 Steam、再將會話中其他受支援的程序壓縮到 zRAM。這是軟性上限:不會關閉任何程式,但在分頁讀回時遊戲可能會卡頓。 @@ -612,7 +638,7 @@ 只限 Adreno。減少卡頓,但更耗電、更發熱。 會話修正 Turnip:sysmem 渲染 - Steam 用戶端會更快;遊戲中驅動程式會為每個渲染通道選擇分塊渲染或系統記憶體渲染。Adreno 710/720/722 必須開啟。 + 適用於 Steam 用戶端和遊戲。Adreno 710/720/722 必須開啟。 略過 Steam 的 xalia 輔助程式 droiddeck-ntsync 在用戶空間代替 Linux ntsync 驅動程式。開啟時,Proton 會使用它而非 droiddeck-esync 和 droiddeck-fsync。適用於 Proton Experimental ARM64、GE-Proton 和 proton-cachyos。下次會話生效。 @@ -1815,6 +1841,7 @@ %1$s ✓ Ctrl+C Ctrl+D + 清除 請先安裝運行環境 無法使用 Steam 收藏庫 無法使用先前的 SD 卡收藏庫 @@ -3805,8 +3832,6 @@ Alt+Tab、Win 鍵和主頁鍵留在工作階段中 在 Android 中呈灰色?應用程式資訊 → ⋮ → 允許受限制的設定 已被 Android 封鎖 · 應用程式資訊 → ⋮ → 允許受限制的設定 - DroidDeck 系統按鍵 - 讓 Alt+Tab、Win 鍵和主頁鍵在目前的 DroidDeck 工作階段中生效,而不是交給 Android。 請在「初始設定 → Steam 整合」中開啟「亮度」 DXVK DXVK:自動 @@ -3969,10 +3994,11 @@ 重設位置 顯示標籤 無法匯入此佈局 + 透過 %1$s 安裝 緋紅之雪 白色表面配紅色點綴。 - + 原聲帶 音樂 播放選項 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index c080ab3d47..d8fe8ca729 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -9,15 +9,35 @@ DroidDeck 無法自動重新啟動。請完全關閉應用程式,然後重新開啟。 DroidDeck - 首次執行會下載 Steam。這可能需要幾分鐘。 - 預設情況下,離開應用程式會暫停 Steam;返回時會從上次中斷處繼續。 - 你的控制器會被識別為 Xbox 360 手把。沒有控制器時,可使用螢幕控制。 + 首次執行會下載 Steam,可能需要幾分鐘。 + 你的控制器在 Steam 中會顯示為 Steam Deck 控制器。可在工作階段設定中切換為 Steam Controller、DualShock 4、DualSense 或 Xbox 360 控制器,下次工作階段生效。 + 長按控制器上的返回鍵可開啟 Steam 的快速存取選單。必須在工作階段設定中開啟「長按返回鍵使用 Steam 快捷操作」。 + 背景行為決定你離開應用程式時會發生什麼:「原生」會讓 Steam 做好休眠準備,「自動」會暫停,「手動」會等你點擊「繼續」,「從不」則保持執行。 + Steam 遊戲使用快速存取中 Steam 的影格率限制。如果有能被該上限整除的更新率,顯示器會切換到該更新率。 + 工作階段選單中的低延遲模式會以 1000 Hz 而非 250 Hz 傳送控制器輸入,代價是略多一點 CPU 和電量消耗。 + 每個遊戲都有自己的設定檔,包含 Proton、FEX、元件和環境設定。 + 工作階段選單裡有用於語音聊天的麥克風開關,以及可隨時凍結工作階段的「立即暫停」按鈕。 + 拖曳 DroidDeck HUD 可移動它,雙指捏合可調整大小,推到螢幕邊緣可停靠為小型 FPS 分頁。 + 在雙螢幕掌機上,下方螢幕可以顯示下載、通知、截圖和 Steam 聊天。「交換螢幕」會改為把遊戲放到下方螢幕。 + 可加入 SD 卡、USB 隨身碟或 SSD 上的 Steam 遊戲庫,DroidDeck 會把這些遊戲集中在你的收藏庫中。 + 「遊戲商店」讓你登入 Epic Games、GOG、Xbox、EA、Battle.net、Ubisoft Connect、Amazon Games、itch.io 和 Game Jolt,然後在 DroidDeck 中安裝和更新它們的遊戲。 + FEX、DXVK 和 VKD3D-Proton 等元件會自動更新,預設使用 Proton Experimental ARM64,安裝 Proton 11.0 ARM64 後則預設使用它。 + 「遊戲執行時壓縮 Steam」可在記憶體不足的裝置上釋放 RAM。 + 從右邊緣向內滑動可開啟工作階段選單:觸控板模式、電腦鍵盤、低延遲、遊戲設定檔等。 + 遊戲執行緩慢?先在快速存取中限制影格率,再到遊戲的元件中嘗試其他 Proton 版本或 FEX 預設。 + 遊戲音訊爆音或沒有聲音?請在 Steam 設定的「音訊」下嘗試「遊戲使用 DirectAudio」開關。 + 「設定」下的「儲存空間」可以清理已移除遊戲留下的著色器快取和殘留前綴。 + 遇到故障?工作階段選單中的「分享日誌」會打包診斷資訊。請發布到 Discord 的 #bug-reports。 - 首次執行會設定桌面。這可能需要幾分鐘。 - 預設情況下,離開應用程式會暫停工作階段;返回時會從上次中斷處繼續。 - 觸控會像觸控板一樣運作:拖曳移動指標,輕觸即點擊。 - 你的控制器會被識別為 Xbox 360 手把。沒有控制器時,可使用螢幕控制。 + 首次執行會設定桌面,可能需要幾分鐘。 + 觸控的作用類似觸控板:拖曳可移動游標,輕點即可點按。 + 背景行為決定你離開應用程式時會發生什麼:「手動」預設會等你點擊「繼續」,「自動」會暫停,「從不」則保持執行。 + 從右邊緣向內滑動可開啟工作階段選單,然後選擇「電腦鍵盤」,即可在忽略 Android 鍵盤的應用程式中輸入。 + 工作階段選單中的電腦鍵盤可調整大小、不透明度和按鍵群組。 + 你的控制器會顯示為 Xbox 360 控制器。否則請使用螢幕上的控制項。 + 工作階段選單裡有麥克風開關和可隨時凍結工作階段的「立即暫停」按鈕。 + 遇到故障?工作階段選單中的「分享日誌」會打包診斷資訊。請發布到 Discord 的 #bug-reports。 工作階段 在 Steam 或桌面工作階段開啟時顯示 @@ -269,6 +289,10 @@ 觸控板 直接 自動:桌面使用觸控板,Steam 使用直接觸控。 + 觸控筆 + 滑鼠 + 觸控 + 側鍵 螢幕控制 Steam + QAM 自動模式會在未連接控制器時顯示螢幕控制。 @@ -602,6 +626,8 @@ 關閉 驅動程式預設值 遊戲執行時壓縮 Steam + 壓縮遊戲閒置記憶體 + RAM 偏低時壓縮遊戲閒置記憶體。如果遊戲大約每半分鐘凍結幾秒,請關閉此項。下次啟動工作階段時生效。 遊戲啟動 20 秒後,Steam 用戶端會被壓縮到 zRAM,為遊戲騰出更多記憶體,並在遊戲關閉時讀回。如果工作階段在遊戲啟動後不久就關閉,請關閉此選項。若超過上方的 RAM 上限,工作階段仍會壓縮 Steam。 RAM 上限 在 Steam 用戶端執行時生效,無論是 Steam 模式或從桌面啟動。當工作階段的用量超過此值時,會先將 Steam、再將工作階段中其他受支援的程序壓縮到 zRAM。這是軟性上限:不會關閉任何程式,但在分頁讀回時遊戲可能會卡頓。 @@ -612,7 +638,7 @@ 僅適用於 Adreno。卡頓更少,但耗電和發熱更多。 工作階段修復 Turnip:sysmem 渲染 - Steam 用戶端會更快;遊戲中驅動程式會為每個算繪通道選擇分塊算繪或系統記憶體算繪。Adreno 710/720/722 必需。 + 適用於 Steam 用戶端和遊戲。Adreno 710/720/722 必需。 跳過 Steam 的 xalia 輔助程式 droiddeck-ntsync 以使用者空間替代 Linux ntsync 驅動程式。開啟時,Proton 會使用它來取代 droiddeck-esync 和 droiddeck-fsync。適用於 Proton Experimental ARM64、GE-Proton 和 proton-cachyos。下次工作階段生效。 @@ -1815,6 +1841,7 @@ %1$s ✓ Ctrl+C Ctrl+D + 清除 請先安裝執行環境 無法使用 Steam 收藏庫 無法使用先前的 SD 卡收藏庫 @@ -3805,8 +3832,6 @@ Alt+Tab、Win 鍵和主畫面鍵留在工作階段中 在 Android 中呈灰色?應用程式資訊 → ⋮ → 允許受限制的設定 已被 Android 封鎖 · 應用程式資訊 → ⋮ → 允許受限制的設定 - DroidDeck 系統按鍵 - 讓 Alt+Tab、Win 鍵和主畫面鍵在目前的 DroidDeck 工作階段中生效,而不是交給 Android。 請在「初始設定 → Steam 整合」中開啟「亮度」 DXVK DXVK:自動 @@ -3969,10 +3994,11 @@ 重設位置 顯示標籤 無法匯入此版面配置 + 透過 %1$s 安裝 緋紅之雪 白色表面搭配紅色點綴。 - + 原聲帶 音樂 播放選項 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 5cedd4524d..737a1b7d46 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -37,14 +37,34 @@ Scroll speed First run downloads Steam. This may take a few minutes. - By default, leaving the app pauses Steam; it picks up where it left off when you come back. - Your controller appears as an Xbox 360 pad. Otherwise, use the on-screen controls. + Your controller shows up to Steam as a Steam Deck controller. Switch it to a Steam Controller, DualShock 4, DualSense or Xbox 360 pad in the session settings; it applies next session. + Hold Back on your controller to open Steam\'s Quick Access menu. Hold Back for Steam shortcuts must be on in the session settings. + Background behavior decides what happens when you leave the app: Native readies Steam for sleep, Auto pauses it, Manual waits for Resume, Never keeps it running. + Steam games use Steam\'s Frame Limit in Quick Access. The display switches to a refresh rate the cap divides evenly when it has one. + Low latency mode in the session menu sends controller input at 1000 Hz instead of 250 Hz, for a bit more CPU and battery. + Each game has its own profile with Proton, FEX, components and environment settings. + The session menu has a microphone toggle for voice chat and a Suspend now button to freeze the session on demand. + Drag the DroidDeck HUD to move it, pinch to resize it, and push it off an edge to dock it as a small FPS tab. + On dual-screen handhelds, the bottom screen can show downloads, notifications, screenshots and Steam chat. Swap screens puts the game down there instead. + Add Steam libraries from an SD card, USB drive or SSD, and DroidDeck keeps the games together in your Library. + Stores lets you sign in to Epic Games, GOG, Xbox, EA, Battle.net, Ubisoft Connect, Amazon Games, itch.io and Game Jolt, then install and update their games from DroidDeck. + Components like FEX, DXVK and VKD3D-Proton update themselves, and Proton Experimental ARM64 is the default, or Proton 11.0 ARM64 once that build is installed. + Compress Steam while a game runs frees RAM on devices that run low. + Swipe in from the right edge to open the session menu: touchpad mode, PC keyboard, low latency, game profile and more. + Game running slow? Cap the frame rate in Quick Access, then try another Proton version or FEX preset in the game\'s components. + Crackling or missing game audio? Try the DirectAudio for games toggle in Steam settings under Audio. + Setup, then Storage, can clear shader caches and leftover prefixes from games you removed. + Hitting a bug? Share logs in the session menu bundles diagnostics. Post them in #bug-reports on Discord. First run sets up the desktop. This may take a few minutes. - By default, leaving the app pauses the session; it picks up where it left off when you come back. Touch works as a touchpad: drag to move the pointer, tap to click. - Your controller appears as an Xbox 360 pad. Otherwise, use the on-screen controls. + Background behavior decides what happens when you leave the app: Manual waits for Resume by default, Auto pauses, Never keeps it running. + Swipe in from the right edge to open the session menu, then pick PC keyboard to type in apps that ignore the Android keyboard. + The PC keyboard in the session menu has adjustable size, opacity and key groups. + Your controller shows up as an Xbox 360 pad. Otherwise, use the on-screen controls. + The session menu has a microphone toggle and a Suspend now button to freeze the session on demand. + Hitting a bug? Share logs in the session menu bundles diagnostics. Post them in #bug-reports on Discord. Session Shows while a Steam or desktop session is open @@ -297,6 +317,10 @@ Touchpad Direct Auto: touchpad on Desktop, direct in Steam. + Pen + Mouse + Touch + Side button On-screen controls Steam + QAM Auto shows the controls when no controller is connected. @@ -632,6 +656,8 @@ Off Driver default Compress Steam while a game runs + Compress idle game memory + Pages out idle game memory when RAM is low. Turn this off if games freeze for a few seconds about every half minute. Applies the next time the session starts. Compresses Steam while a game runs, starting sooner when memory is tight. Steam is read back after the game closes once enough RAM is available. Turn this off if the session closes shortly after games start. A RAM cap above still compresses Steam when the session goes over it. RAM cap Applies while the Steam client runs, in Steam mode or from the desktop. When the session uses more than this, Steam and then the session\'s other supported processes are compressed into zRAM. A soft cap: nothing is closed, but games may stutter while pages come back. @@ -642,7 +668,7 @@ Adreno only. Fewer hitches, more battery use and heat. Session fixes Turnip: sysmem rendering - Faster for the Steam client; in games the driver picks tile or system-memory rendering per pass. Required on Adreno 710/720/722. + Applies to the Steam client and games. Required on Adreno 710/720/722. Skip Steam\'s xalia helper droiddeck-ntsync A userspace stand-in for the Linux ntsync driver. While it is on, Proton uses it instead of droiddeck-esync and droiddeck-fsync. Works with Proton Experimental ARM64, GE-Proton and proton-cachyos. Applies next session. @@ -766,6 +792,13 @@ Reset Scaling mode Scaling sharpness + Edit profile + Choose which profile to change screen effects for. + Current session (automatic) + Reset effects + Restore the default-off effect values for this profile. + Delete saved override + Remove saved effects for this game so it inherits the Default profile. Screen effects Live. Costs a little GPU time while any effect is on. Presets @@ -1182,6 +1215,8 @@ Agent Agent Agent is working + Compact chat in the session drawer + The model, usage and menu share the message row, leaving more room for the conversation MCP servers and skills MCP servers Skills in ~/.claude/skills @@ -1986,6 +2021,7 @@ %1$s ✓ Ctrl+C Ctrl+D + Clear Install the runtime first Steam library is unavailable Previous SD library is unavailable @@ -3338,7 +3374,7 @@ Done Waiting for the glasses’ USB Ethernet connection. This phone may not expose it to apps. The XREAL connection was interrupted or returned an unsupported response. Retrying… - Experimental 1S support. Use Follow mode and disable stabilization in the glasses menu. Tracking directions and display modes still need device testing. + Experimental XREAL 1S, One, One Pro, One Pro+ and Aura support. Use Follow mode and turn off stabilization in the glasses menu; on the Aura, also turn off Spatial Anchor. Head tracking and 2D/3D switching are tested on the Aura. Experimental Pro 2 head tracking. Brightness, volume, and display switching are not supported yet. Picture position Top @@ -3997,9 +4033,9 @@ Home opens the Steam menu in a session Alt+Tab, Win key and Home button stay in the session Greyed out in Android? App info → ⋮ → Allow restricted settings + System keys didn\'t install + System keys didn\'t install: %1$s Blocked by Android · App info → ⋮ → Allow restricted settings - DroidDeck system keys - Keep Alt+Tab, the Win key and the Home button inside a focused DroidDeck session instead of Android. Turn on Brightness in Setup → Steam integration Restoring your software Reinstalling the apps you added after a DroidDeck update. @@ -4068,7 +4104,12 @@ Reset positions Show label Could not import this layout + Installs through %1$s + True black + Pure black page and panels, so an OLED screen switches those pixels off. You pick the highlight color. + Highlight + The color of everything selected. Scarlet Snow White surfaces with red accents. Soundtracks diff --git a/app/src/main/rust/stores/src/epic/catalog.rs b/app/src/main/rust/stores/src/epic/catalog.rs index 420d656e80..ef3d585de0 100644 --- a/app/src/main/rust/stores/src/epic/catalog.rs +++ b/app/src/main/rust/stores/src/epic/catalog.rs @@ -51,6 +51,20 @@ fn attribute_of(entry: &Value, name: &str) -> Option { .map(str::to_string) } +fn third_party_managed_app(entry: &Value) -> Option { + let value = attribute_of(entry, "ThirdPartyManagedApp")?; + let value = value.trim(); + if value.is_empty() { + return None; + } + let launcher = match value.to_ascii_lowercase().as_str() { + "origin" | "ea app" | "the ea app" => "EA app", + "ubisoft connect" | "uplay" => "Ubisoft Connect", + _ => value, + }; + Some(launcher.to_string()) +} + pub fn details_of(entry: &Value) -> Value { let publisher = attribute_of(entry, "publisherName") .map(|p| p.trim().to_string()) @@ -73,6 +87,7 @@ pub fn details_of(entry: &Value) -> Value { "wide": image(entry, &["DieselGameBox", "Thumbnail"]), "logo": image(entry, &["DieselGameBoxLogo"]), "canRunOffline": offline, + "thirdPartyManagedApp": third_party_managed_app(entry).unwrap_or_default(), "dlc": main_game.is_some_and(|m| !m.is_null()), "mainGameId": main_game.map(|m| net::str_of(m, "id")).unwrap_or(""), }) @@ -118,6 +133,7 @@ mod tests { assert_eq!(d["logo"], "logo"); assert_eq!(d["publisher"], "Pub"); assert_eq!(d["canRunOffline"], false); + assert_eq!(d["thirdPartyManagedApp"], ""); assert_eq!(d["releaseDate"], "2020-01-01T00:00:00.000Z"); assert_eq!(d["dlc"], false); let dlc = details_of(&json!({"mainGameItem": {"id": "base"}, "seller": {"name": "S"}, "viewableDate": "v"})); @@ -129,4 +145,14 @@ mod tests { assert_eq!(dlc["logo"], ""); assert_eq!(pick_entry(&json!({"x": {"title": "Only"}}), "y").unwrap()["title"], "Only"); } + + #[test] + fn parses_third_party_managed_launchers() { + let ea = details_of(&json!({"customAttributes": {"ThirdPartyManagedApp": {"value": "Origin"}}})); + let ubisoft = details_of(&json!({"customAttributes": {"ThirdPartyManagedApp": {"value": "Ubisoft Connect"}}})); + let none = details_of(&json!({})); + assert_eq!(ea["thirdPartyManagedApp"], "EA app"); + assert_eq!(ubisoft["thirdPartyManagedApp"], "Ubisoft Connect"); + assert_eq!(none["thirdPartyManagedApp"], ""); + } } diff --git a/app/src/main/rust/stores/src/epic/install/mod.rs b/app/src/main/rust/stores/src/epic/install/mod.rs index df20412aca..8cca149c4e 100644 --- a/app/src/main/rust/stores/src/epic/install/mod.rs +++ b/app/src/main/rust/stores/src/epic/install/mod.rs @@ -50,6 +50,9 @@ pub struct Request { impl Request { pub fn from_json(v: &Value) -> Result { + if let Some(launcher) = v.get("thirdPartyManagedApp").and_then(Value::as_str).map(str::trim).filter(|s| !s.is_empty()) { + return Err(format!("third-party-managed:{launcher}")); + } let info = v.get("info").and_then(BuildInfo::from_json).ok_or("The manifest could not be fetched")?; let game_dir = net::str_of(v, "gameDir"); if game_dir.is_empty() || !game_dir.starts_with('/') { diff --git a/app/src/main/rust/stores/src/epic/install/tests.rs b/app/src/main/rust/stores/src/epic/install/tests.rs index 127d772de7..1f8479f9be 100644 --- a/app/src/main/rust/stores/src/epic/install/tests.rs +++ b/app/src/main/rust/stores/src/epic/install/tests.rs @@ -12,6 +12,15 @@ use crate::epic::chunk::testing::encode; use crate::epic::manifest::testing::{build, chunk, TestFile, TestManifest}; use crate::epic::manifest::{guid_text, PartRef}; +#[test] +fn rejects_third_party_managed_install_before_manifest_parsing() { + let request = serde_json::json!({"thirdPartyManagedApp": "EA app"}); + match Request::from_json(&request) { + Err(error) => assert_eq!(error, "third-party-managed:EA app"), + Ok(_) => panic!("third-party-managed install was accepted"), + } +} + fn serve(files: HashMap>, hits: Arc) -> String { let listener = TcpListener::bind("127.0.0.1:0").unwrap(); let addr = listener.local_addr().unwrap(); diff --git a/app/src/test/java/com/droiddeck/launcher/MaliAutoRouteTest.kt b/app/src/test/java/com/droiddeck/launcher/MaliAutoRouteTest.kt new file mode 100644 index 0000000000..6e7895c5e5 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/MaliAutoRouteTest.kt @@ -0,0 +1,53 @@ +package com.droiddeck.launcher + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +class MaliAutoRouteTest { + @Test + fun defaultBridgeIsOwnedByAuto() { + assertEquals(MaliAutoRoute.BRIDGE, MaliAutoRoute.initialOwnership(true, false, false, false)) + } + + @Test + fun bridgeFallbackIsOwnedByAuto() { + assertEquals(MaliAutoRoute.BRIDGE, MaliAutoRoute.fallbackOwnership(false, false, false, false, false)) + } + + @Test + fun explicitBridgeStaysUserOwned() { + assertEquals(MaliAutoRoute.NONE, MaliAutoRoute.initialOwnership(true, true, false, false)) + assertEquals(MaliAutoRoute.NONE, MaliAutoRoute.fallbackOwnership(false, true, true, false, false)) + } + + @Test + fun explicitVenusStaysUserOwned() { + assertEquals(MaliAutoRoute.NONE, MaliAutoRoute.initialOwnership(false, false, true, true)) + assertEquals(MaliAutoRoute.NONE, MaliAutoRoute.fallbackOwnership(true, false, false, true, true)) + } + + @Test + fun installedMaliPairEndsAutoOwnedRoute() { + assertTrue(MaliAutoRoute.shouldEnd(MaliAutoRoute.BRIDGE, true, true)) + } + + @Test + fun installedAdrenoPairDoesNotEndRoute() { + assertFalse(MaliAutoRoute.shouldEnd(MaliAutoRoute.BRIDGE, false, true)) + } + + @Test + fun aValueAutoStoredItselfIsNotAUserChoice() { + assertFalse(MaliAutoRoute.userChoice(true, MaliAutoRoute.BRIDGE, MaliAutoRoute.BRIDGE)) + assertFalse(MaliAutoRoute.userChoice(true, MaliAutoRoute.VENUS, MaliAutoRoute.VENUS)) + } + + @Test + fun aStoredValueStaysAUserChoiceWhenAutoOwnsNothingForThatRoute() { + assertTrue(MaliAutoRoute.userChoice(true, MaliAutoRoute.NONE, MaliAutoRoute.BRIDGE)) + assertTrue(MaliAutoRoute.userChoice(true, MaliAutoRoute.VENUS, MaliAutoRoute.BRIDGE)) + assertFalse(MaliAutoRoute.userChoice(false, MaliAutoRoute.NONE, MaliAutoRoute.BRIDGE)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/audio/PulseAudioComponentTest.kt b/app/src/test/java/com/droiddeck/launcher/audio/PulseAudioComponentTest.kt new file mode 100644 index 0000000000..d06cc52d03 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/audio/PulseAudioComponentTest.kt @@ -0,0 +1,105 @@ +package com.droiddeck.launcher.audio + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit +import java.util.concurrent.Executors + +class PulseAudioComponentTest { + @Test + fun stopCancelsSetupAndAcceptedRestart() { + val killed = mutableListOf() + val host = PulseAudioComponent.HostLifecycle { killed.add(it) } + val generation = host.begin() + assertTrue(host.launch(generation) { 31463 }) + assertTrue(host.exited(generation)) + host.stop() + assertFalse(host.launch(generation) { error("cancelled restart launched") }) + val next = host.begin() + host.stop() + assertFalse(host.launch(next) { error("cancelled setup launched") }) + assertEquals(-1, host.pid) + } + + @Test + fun explicitStartStillWorksAndStaleExitCannotRestartIt() { + val killed = mutableListOf() + val host = PulseAudioComponent.HostLifecycle { killed.add(it) } + val first = host.begin() + host.launch(first) { 31463 } + val second = host.begin() + host.launch(second) { 31464 } + assertEquals(listOf(31463), killed) + assertFalse(host.exited(first)) + assertEquals(31464, host.pid) + host.stop() + assertEquals(listOf(31463, 31464), killed) + assertFalse(host.exited(second)) + } + + @Test + fun anOvertakenRestartIsNoLongerCurrent() { + val host = PulseAudioComponent.HostLifecycle { } + val first = host.begin() + host.launch(first) { 31463 } + assertTrue(host.exited(first)) + assertTrue(host.current(first)) + val second = host.begin() + assertFalse(host.current(first)) + assertTrue(host.current(second)) + } + + @Test + fun aSinkGuardOnlyActsOnItsOwnLaunch() { + val host = PulseAudioComponent.HostLifecycle { } + val generation = host.begin() + host.launch(generation) { 31463 } + val first = host.token() + assertTrue(host.live(first)) + assertTrue(host.exited(generation)) + assertFalse(host.live(first)) + host.launch(generation) { 31464 } + assertFalse(host.live(first)) + assertTrue(host.live(host.token())) + host.stop() + assertFalse(host.live(host.token())) + } + + @Test + fun failedLaunchDoesNotRestartOrTerminateAnInvalidPid() { + val host = PulseAudioComponent.HostLifecycle { error("invalid pid terminated") } + val generation = host.begin() + assertTrue(host.launch(generation) { -1 }) + assertFalse(host.exited(generation)) + host.stop() + } + + @Test + fun earlyExitWaitsForPidPublication() { + val host = PulseAudioComponent.HostLifecycle { } + val generation = host.begin() + val entered = CountDownLatch(1) + val pool = Executors.newSingleThreadExecutor() + try { + lateinit var exit: java.util.concurrent.Future + assertTrue(host.launch(generation) { + exit = pool.submit { + entered.countDown() + host.exited(generation) + } + assertTrue(entered.await(5, TimeUnit.SECONDS)) + assertFalse(exit.isDone) + 31463 + }) + assertTrue(exit.get(5, TimeUnit.SECONDS)) + assertEquals(-1, host.pid) + assertTrue(host.launch(generation) { 31464 }) + assertEquals(31464, host.pid) + } finally { + pool.shutdownNow() + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/core/PhantomProcessLimitTest.kt b/app/src/test/java/com/droiddeck/launcher/core/PhantomProcessLimitTest.kt index e1f0b1af3f..3f05d01a36 100644 --- a/app/src/test/java/com/droiddeck/launcher/core/PhantomProcessLimitTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/core/PhantomProcessLimitTest.kt @@ -58,6 +58,24 @@ class PhantomProcessLimitTest { assertFalse(PhantomProcessLimit.verified("null", enabled = false, sdk = 33)) } + @Test + fun android12LKeepsTheFlagAndNotTheCountLimit() { + assertFalse(PhantomProcessLimit.usesDeviceConfig(32)) + assertEquals( + listOf("settings put global settings_enable_monitor_phantom_procs false"), + PhantomProcessLimit.shellCommands(enabled = false, sdk = 32), + ) + } + + @Test + fun android12KeepsTheCountLimitBecauseItHasNoFlag() { + assertTrue(PhantomProcessLimit.usesDeviceConfig(31)) + assertTrue( + PhantomProcessLimit.shellCommands(enabled = false, sdk = 31) + .any { it.startsWith("device_config put activity_manager max_phantom_processes") } + ) + } + @Test fun developerToggleStartsAtAndroid14() { assertFalse(PhantomProcessLimit.hasDeveloperToggle(33)) diff --git a/app/src/test/java/com/droiddeck/launcher/core/SessionLogCaptureTest.kt b/app/src/test/java/com/droiddeck/launcher/core/SessionLogCaptureTest.kt new file mode 100644 index 0000000000..bfa775681d --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/core/SessionLogCaptureTest.kt @@ -0,0 +1,17 @@ +package com.droiddeck.launcher.core + +import org.junit.Assert.assertEquals +import org.junit.Test + +class SessionLogCaptureTest { + @Test fun captureStartsFromTheSessionFolderTime() { + assertEquals( + "/system/bin/logcat -v threadtime -T 1731100000.007 --pid=42", + SessionLogCapture.command(42, 1_731_100_000_007L), + ) + } + + @Test fun withoutAStartTimeOnlyNewLinesAreCaptured() { + assertEquals("/system/bin/logcat -v threadtime -T 1 --pid=42", SessionLogCapture.command(42, 0L)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/core/SteamIntegrationShortcutsTest.kt b/app/src/test/java/com/droiddeck/launcher/core/SteamIntegrationShortcutsTest.kt deleted file mode 100644 index 961d3d25ab..0000000000 --- a/app/src/test/java/com/droiddeck/launcher/core/SteamIntegrationShortcutsTest.kt +++ /dev/null @@ -1,97 +0,0 @@ -package com.droiddeck.launcher.core - -import android.app.Application -import android.content.ComponentName -import android.content.Intent -import android.content.pm.PackageManager -import android.provider.Settings -import androidx.test.core.app.ApplicationProvider -import com.droiddeck.launcher.input.HomeButtonService -import org.junit.Assert.assertEquals -import org.junit.Assert.assertFalse -import org.junit.Assert.assertTrue -import org.junit.Test -import org.junit.runner.RunWith -import org.robolectric.RobolectricTestRunner -import org.robolectric.annotation.Config - -@RunWith(RobolectricTestRunner::class) -@Config(sdk = [33], application = Application::class) -class SteamIntegrationShortcutsTest { - private val context: Application = ApplicationProvider.getApplicationContext() - private val service = ComponentName(context, HomeButtonService::class.java) - - private fun listed() = context.packageManager.queryIntentServices( - Intent("android.accessibilityservice.AccessibilityService").setPackage(context.packageName), 0, - ).any { ComponentName(it.serviceInfo.packageName, it.serviceInfo.name) == service } - - private fun choose(value: String?) = - Settings.Secure.putString(context.contentResolver, Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, value) - - @Test fun theShortcutsServiceIsHiddenUntilChosen() { - assertTrue(listed()) - assertFalse(SteamIntegration.shortcutsChosen(context)) - SteamIntegration.syncShortcutsListing(context) - assertFalse(listed()) - assertEquals(PackageManager.COMPONENT_ENABLED_STATE_DISABLED, context.packageManager.getComponentEnabledSetting(service)) - } - - @Test fun anUpdateKeepsAServiceTheUserAlreadyTurnedOn() { - choose(service.flattenToString()) - SteamIntegration.syncShortcutsListing(context) - assertTrue(listed()) - assertTrue(SteamIntegration.shortcutsChosen(context)) - } - - @Test fun openingShortcutSetupListsTheServiceAndBackingOutHidesItAgain() { - SteamIntegration.setShortcutsListed(context, true) - assertTrue(listed()) - SteamIntegration.syncShortcutsListing(context) - assertFalse(listed()) - assertEquals(PackageManager.COMPONENT_ENABLED_STATE_DISABLED, context.packageManager.getComponentEnabledSetting(service)) - } - - @Test fun aChosenServiceStaysListed() { - choose("other.app/.Reader:" + service.flattenToShortString()) - assertTrue(SteamIntegration.shortcutsChosen(context)) - SteamIntegration.syncShortcutsListing(context) - assertTrue(listed()) - choose(service.flattenToString()) - assertTrue(SteamIntegration.shortcutsChosen(context)) - choose("other.app/.Reader") - assertFalse(SteamIntegration.shortcutsChosen(context)) - SteamIntegration.syncShortcutsListing(context) - assertFalse(listed()) - } - - @Test fun anUpdateHidesAnUnchosenServiceWithoutOpeningDroidDeck() { - val replaced = Intent(Intent.ACTION_MY_PACKAGE_REPLACED).setPackage(context.packageName) - assertTrue(context.packageManager.queryBroadcastReceivers(replaced, 0) - .any { it.activityInfo.name == ShortcutsListingReceiver::class.java.name }) - assertTrue(listed()) - ShortcutsListingReceiver().onReceive(context, replaced) - assertFalse(listed()) - } - - @Test fun anUpdateLeavesAChosenServiceListed() { - choose(service.flattenToString()) - ShortcutsListingReceiver().onReceive(context, Intent(Intent.ACTION_MY_PACKAGE_REPLACED)) - assertTrue(listed()) - assertTrue(SteamIntegration.shortcutsChosen(context)) - } - - @Test fun otherBroadcastsChangeNothing() { - ShortcutsListingReceiver().onReceive(context, Intent(Intent.ACTION_BOOT_COMPLETED)) - assertTrue(listed()) - } - - @Test fun turningTheServiceOffInSettingsHidesItAtOnce() { - choose(service.flattenToString()) - val running = org.robolectric.Robolectric.buildService(HomeButtonService::class.java).create().get() - running.onUnbind(null) - assertTrue(listed()) - choose("") - running.onUnbind(null) - assertFalse(listed()) - } -} diff --git a/app/src/test/java/com/droiddeck/launcher/files/FileManagerNavigationTest.kt b/app/src/test/java/com/droiddeck/launcher/files/FileManagerNavigationTest.kt index cbcf207553..0b04410a25 100644 --- a/app/src/test/java/com/droiddeck/launcher/files/FileManagerNavigationTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/files/FileManagerNavigationTest.kt @@ -17,4 +17,14 @@ class FileManagerNavigationTest { assertTrue(canNavigateUp(child, drive)) assertFalse(canNavigateUp(drive, drive)) } + + @Test fun backLeavesInsteadOfHoppingBetweenTwoRoots() { + val drive = tmp.newFolder("drive") + val other = tmp.newFolder("other") + val child = File(drive, "folder").apply { mkdir() } + + assertTrue(backExitsAtRootHop(drive, drive, other to other)) + assertFalse(backExitsAtRootHop(drive, drive, child to other)) + assertFalse(backExitsAtRootHop(child, drive, other to other)) + } } diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/GameFileSyncTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/GameFileSyncTest.kt index a4e3b00283..93a7c352f3 100644 --- a/app/src/test/java/com/droiddeck/launcher/frontend/GameFileSyncTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/frontend/GameFileSyncTest.kt @@ -47,4 +47,52 @@ class GameFileSyncTest { assertFalse(File(folder, "Geometry Wars.steam").exists()) assertEquals(0, folder.listFiles()!!.count { it.extension == GameFiles.EXTENSION }) } + + @Test fun libraryNotCreatedYetOnPresentStorageIsEmptyNotUnavailable() { + val context = RuntimeEnvironment.getApplication() + val root = LinuxRuntime.rootDir(context) + listOf("usr/bin/gamescope", LinuxRuntime.SESSION_SCRIPT.removePrefix("/"), "opt/android-host/proot", "opt/android-host/loader").forEach { path -> + File(root, path).apply { parentFile!!.mkdirs(); writeText("") } + } + SessionPrefs.setAddedGamesDirs(context, emptyList()) + File(root, "root/.local/share/Steam/steamapps").mkdirs() + val volume = File(context.filesDir, "card").apply { mkdirs() } + val library = File(volume, "steam") + SessionPrefs.setGameStorage(context, library.path, "Card") + val folder = File(context.filesDir, "exports-card").apply { mkdirs() } + GameFileSync.enable(context, folder) + assertEquals(folder.path, GameFileSync.folder(context)) + assertFalse(library.exists()) + library.writeText("") + assertThrows(IllegalStateException::class.java) { GameFileSync.syncConfigured(context) } + assertTrue(library.delete()) + GameFileSync.disable(context) + } + + @Test fun libraryReadableOnlyWhenListableOrNotCreatedOnPresentParent() { + val base = File(RuntimeEnvironment.getApplication().filesDir, "readable").apply { mkdirs() } + assertTrue(GameFileSync.libraryReadable(File(base, "dir").apply { mkdirs() })) + assertTrue(GameFileSync.libraryReadable(File(base, "missing"))) + assertFalse(GameFileSync.libraryReadable(File(base, "gone/steam"))) + assertFalse(GameFileSync.libraryReadable(File(base, "file").apply { writeText("") })) + } + + @Test fun previousAutomaticLibraryNotCreatedYetKeepsSyncingButRemovedDriveStops() { + val context = RuntimeEnvironment.getApplication() + val root = LinuxRuntime.rootDir(context) + listOf("usr/bin/gamescope", LinuxRuntime.SESSION_SCRIPT.removePrefix("/"), "opt/android-host/proot", "opt/android-host/loader").forEach { path -> + File(root, path).apply { parentFile!!.mkdirs(); writeText("") } + } + SessionPrefs.setAddedGamesDirs(context, emptyList()) + SessionPrefs.setGameStorage(context, "", "") + File(root, "root/.local/share/Steam/steamapps").mkdirs() + val folder = File(context.filesDir, "exports-auto").apply { mkdirs() } + val prefs = context.getSharedPreferences("game_files", android.content.Context.MODE_PRIVATE) + val volume = File(context.filesDir, "auto-card").apply { mkdirs() } + prefs.edit().putString("storageSetting", "").putString("storagePath", File(volume, "steam").path).apply() + GameFileSync.enable(context, folder) + prefs.edit().putString("storageSetting", "").putString("storagePath", File(context.filesDir, "removed-card/steam").path).apply() + assertThrows(IllegalStateException::class.java) { GameFileSync.syncConfigured(context) } + GameFileSync.disable(context) + } } diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/Glasses3dRoutingTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/Glasses3dRoutingTest.kt index d40441552d..9d08945cd8 100644 --- a/app/src/test/java/com/droiddeck/launcher/glasses/Glasses3dRoutingTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/glasses/Glasses3dRoutingTest.kt @@ -30,7 +30,8 @@ class Glasses3dRoutingTest { RayNeoModel.model(0x1bbb, 0xaf50, "RayNeo Air 4 Pro")!!, RayNeoModel.model(0x3941, 0xaf50, "RayNeo GT")!!, RayNeoModel.model(0x3941, 0xaf50, "RayNeo GT MAX")!!, - XrealModel, + XrealModel.ONE_S, + XrealModel.AURA, ) private fun field(name: String) = Glasses::class.java.getDeclaredField(name).apply { isAccessible = true } diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesUsbTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesUsbTest.kt index 14dcf26d69..ba2d444afd 100644 --- a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesUsbTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesUsbTest.kt @@ -252,10 +252,14 @@ class GlassesUsbTest { .apply { isAccessible = true }.invoke(Glasses, ask) } - @Test fun xreal1SUsesExactIdentityAndExcludesAirOneProAndRecoveryProducts() { - assertEquals(XrealModel, Glasses.deviceModel(device(0x043e, 0x3318, "XREAL 1S"))) + @Test fun xrealOneFamilyUsesExactIdentityAndExcludesAirAndRecoveryProducts() { + assertEquals(XrealModel.ONE_S, Glasses.deviceModel(device(0x043e, 0x3318, "XREAL 1S"))) + assertEquals(XrealModel.ONE, Glasses.deviceModel(device(0x0438, 0x3318, "XREAL One"))) + assertEquals(XrealModel.ONE_PRO, Glasses.deviceModel(device(0x0436, 0x3318, "XREAL One Pro"))) + assertEquals(XrealModel.ONE_PRO_PLUS, Glasses.deviceModel(device(0x0444, 0x3318, "XREAL 1 Pro+"))) + assertEquals(XrealModel.AURA, Glasses.deviceModel(device(0x043a, 0x3318, "XREAL Aura"))) assertTrue(Glasses.isGlassesDisplayName("XREAL 1S")) - for (pid in listOf(0x043d, 0x0435, 0x0436, 0x0424, 0xffff)) { + for (pid in listOf(0x043d, 0x0435, 0x0437, 0x0439, 0x0443, 0x0424, 0xffff)) { assertEquals(null, Glasses.deviceModel(device(pid, 0x3318, "XREAL 1S"))) } assertEquals(null, Glasses.deviceModel(device(0x043e, 0x1234, "XREAL 1S"))) diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/XrealOrientationFilterTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/XrealOrientationFilterTest.kt index 4aa94d69bc..abd38d30bf 100644 --- a/app/src/test/java/com/droiddeck/launcher/glasses/XrealOrientationFilterTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/glasses/XrealOrientationFilterTest.kt @@ -60,6 +60,12 @@ class XrealOrientationFilterTest { } } + @Test fun auraAxesAreNotFlippedLikeTheRestOfTheOneFamily() { + val aura = XrealOrientationFilter(flipYz = false).update(sample(1000000, accel = Vec3(0f, 9.81f, 0f)))!! + assertTrue(matrix(aura)[7] > 0.99f) + assertNull(XrealOrientationFilter(flipYz = false).update(sample(1000000, accel = Vec3(0f, 0f, 0f)))) + } + @Test fun capturedNeutralGravityStartsUprightBeforeRecenter() { val pose = XrealOrientationFilter().update(sample(1000000, accel = Vec3(-0.0909f, -9.6529f, -1.0731f)))!! diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/XrealProtocolTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/XrealProtocolTest.kt index c84cd7cdba..23f4f5af1c 100644 --- a/app/src/test/java/com/droiddeck/launcher/glasses/XrealProtocolTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/glasses/XrealProtocolTest.kt @@ -69,6 +69,20 @@ class XrealProtocolTest { assertEquals(26, output.size()) } + @Test fun stereoOnlyControlSwitches3dWithoutDisplayModeCommands() { + val output = ByteArrayOutputStream() + val replies = response(XrealProtocol.GET_INPUT, 1, byteArrayOf(0x22, 0)) + + response(XrealProtocol.SET_INPUT, 2, byteArrayOf(0x22, 0)) + + response(XrealProtocol.GET_INPUT, 3, byteArrayOf(0x22, 2, 0x10, 1)) + val control = XrealControl(channels(replies.inputStream(), output), stereoOnly = true, settleDelayMs = 0) + assertEquals(XrealModel.NATIVE_60HZ, control.display()) + assertEquals(5, control.changeDisplay(5)) + val written = output.toByteArray().inputStream() + val commands = List(3) { XrealProtocol.read(written).command } + assertEquals(listOf(XrealProtocol.GET_INPUT, XrealProtocol.SET_INPUT, XrealProtocol.GET_INPUT), commands) + assertFalse(commands.any { it == XrealProtocol.GET_DISPLAY || it == XrealProtocol.SET_DISPLAY }) + } + @Test fun unrelatedResponsesCannotKeepControlWaitingForever() { val replies = ByteArrayOutputStream().apply { repeat(32) { write(frame(0x272e, ByteArray(8))) } } val control = XrealControl(channels(replies.toByteArray().inputStream(), ByteArrayOutputStream())) @@ -79,7 +93,9 @@ class XrealProtocolTest { val reply = byteArrayOf(0x22, 2, 0x10, 0x1d) val control = XrealControl(channels(response(0x275e, 1, reply).inputStream(), ByteArrayOutputStream())) assertEquals(29, control.display()) - assertEquals(29, XrealModel.mode(60, false)) + assertEquals(29, XrealModel.ONE_S.mode(60, false)) + assertEquals(29, XrealModel.AURA.mode(120, false)) + assertEquals(5, XrealModel.AURA.mode(60, true)) } @Test fun stereoWaitsForEdidChangeWithoutSendingASecondModeCommandWhileBusy() { diff --git a/app/src/test/java/com/droiddeck/launcher/gpu/TurnipDriverAutoTest.kt b/app/src/test/java/com/droiddeck/launcher/gpu/TurnipDriverAutoTest.kt index 123fcee195..0be48d5d73 100644 --- a/app/src/test/java/com/droiddeck/launcher/gpu/TurnipDriverAutoTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/gpu/TurnipDriverAutoTest.kt @@ -57,7 +57,12 @@ class TurnipDriverAutoTest { gpu(0, adreno = false) to "system", gpu(0) to "turnip25.1.0", gpu(650) to "turnip26.3.0-a6xx", + gpu(710) to "system", + gpu(720) to "system", + gpu(722) to "system", gpu(730) to "turnip25.1.0", + gpu(740) to "turnip25.1.0", + gpu(750) to "turnip25.1.0", gpu(850) to "turnip-sdk36", )) { var calls = 0 @@ -96,6 +101,66 @@ class TurnipDriverAutoTest { assertEquals("test-pinned", TurnipDriver(context) { error("manual choice must precede detection") }.install()) } + @Test fun autoInstalledLowSevenDisplayDriverFallsBackToSystem() { + val context = RuntimeEnvironment.getApplication() + val dir = File(context.filesDir, "graphics_driver/test-pinned").apply { mkdirs() } + File(dir, "meta.json").writeText("""{"libraryName":"test.so"}""") + File(dir, "test.so").writeText("") + SessionPrefs.setAndroidDriver(context, "test-pinned") + SessionPrefs.setGpuAutoInstalled(context, setOf("test-pinned")) + assertEquals("system", TurnipDriver(context) { gpu(710) }.autoId()) + } + + + private fun pin(library: String): String { + val context = RuntimeEnvironment.getApplication() + val dir = File(context.filesDir, "graphics_driver/test-pinned").apply { mkdirs() } + File(dir, "meta.json").writeText("""{"libraryName":"test.so"}""") + File(dir, "test.so").writeText(library) + SessionPrefs.setAndroidDriver(context, "test-pinned") + return "test-pinned" + } + + @Test fun aPickedDriverThatNeedsKgslFallsBackToTheSystemLoaderWithoutKgsl() { + val context = RuntimeEnvironment.getApplication() + pin("\u0000tu_kgsl\u0000/dev/kgsl-3d0\u0000") + val driver = TurnipDriver(context) { error("manual choice must precede detection") } + assertEquals(null, driver.install()) + assertEquals("system", driver.effectiveId()) + assertEquals(false, driver.reachesGpu("test-pinned")) + } + + @Test fun aPickedDriverForAnotherKernelInterfaceIsStillLoaded() { + val context = RuntimeEnvironment.getApplication() + val id = pin("\u0000panvk\u0000/dev/mali0\u0000") + val driver = TurnipDriver(context) { error("manual choice must precede detection") } + assertEquals(id, driver.install()) + assertEquals(id, driver.effectiveId()) + } + + @Test fun kgslDriversStayUsableWhereKgslExists() { + val lib = File(RuntimeEnvironment.getApplication().filesDir, "graphics_driver/test-pinned/test.so") + lib.parentFile!!.mkdirs() + lib.writeText("/dev/kgsl-3d0") + assertEquals(false, TurnipDriver.needsMissingKgsl(lib, true)) + assertEquals(true, TurnipDriver.needsMissingKgsl(lib, false)) + lib.writeText("/dev/mali0") + assertEquals(false, TurnipDriver.needsMissingKgsl(lib, false)) + assertEquals(false, TurnipDriver.needsMissingKgsl(File(lib.parentFile, "absent.so"), false)) + } + + @Test fun kgslIsTheKernelInterfaceNotTheVendorVulkanLibrary() { + val root = File(RuntimeEnvironment.getApplication().filesDir, "kgsl-probe").apply { mkdirs() } + val node = File(root, "dev-kgsl-3d0") + val sysfs = File(root, "sys-kgsl-3d0") + assertEquals(false, TurnipDriver.kgslPresent(node, sysfs)) + node.writeText("") + assertEquals(true, TurnipDriver.kgslPresent(node, sysfs)) + node.delete() + sysfs.mkdirs() + assertEquals(true, TurnipDriver.kgslPresent(node, sysfs)) + } + @Test fun normalizedGpuModelsSelectExistingGenerationDrivers() { for (sdk in listOf(28, 36)) { assertEquals("turnip26.3.0-a6xx", TurnipDriver.chooseByModel(650, sdk)) diff --git a/app/src/test/java/com/droiddeck/launcher/input/FakeInputImuModeTest.kt b/app/src/test/java/com/droiddeck/launcher/input/FakeInputImuModeTest.kt new file mode 100644 index 0000000000..32ed42f1ff --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/input/FakeInputImuModeTest.kt @@ -0,0 +1,37 @@ +package com.droiddeck.launcher.input + +import org.junit.Assert.assertEquals +import org.junit.Test + +class FakeInputImuModeTest { + private fun set(mode: Int) = Int.MIN_VALUE or mode + + @Test fun motionIsUnknownUntilEitherProcessSetsAMode() { + assertEquals(-1, ImuModes.combine(0, 0, GONE)) + } + + @Test fun motionFollowsSteamAloneBeforeRemotePlayStarts() { + assertEquals(0x18, ImuModes.combine(set(0x18), 0, GONE)) + assertEquals(0, ImuModes.combine(set(0), 0, GONE)) + } + + @Test fun motionStaysOnWhileEitherProcessWantsIt() { + assertEquals(0x18, ImuModes.combine(set(0), set(0x18), RUNNING)) + assertEquals(0x18, ImuModes.combine(set(0x18), set(0), RUNNING)) + } + + @Test fun remotePlayDecidesWhileSteamHasSetNoMode() { + assertEquals(0, ImuModes.combine(0, set(0), RUNNING)) + assertEquals(0x18, ImuModes.combine(0, set(0x18), RUNNING)) + } + + @Test fun aRemotePlayClientThatHasGoneIsIgnored() { + assertEquals(0, ImuModes.combine(set(0), set(0x18), GONE)) + assertEquals(-1, ImuModes.combine(0, set(0x18), GONE)) + } + + private companion object { + const val RUNNING = true + const val GONE = false + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/input/HidMouseReportTest.kt b/app/src/test/java/com/droiddeck/launcher/input/HidMouseReportTest.kt new file mode 100644 index 0000000000..7e62907cb3 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/input/HidMouseReportTest.kt @@ -0,0 +1,65 @@ +package com.droiddeck.launcher.input + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertNull +import org.junit.Test + +class HidMouseReportTest { + private fun bytes(hex: String) = hex.split(' ').filter { it.isNotEmpty() }.map { it.toInt(16).toByte() }.toByteArray() + + private fun HidMouseReport.decode(hex: String) = bytes(hex).let { decode(it, it.size) } + + /** A MOSART 2.4G receiver (062a:4c01), as read on a REDMAGIC 10 Pro. */ + private val receiver = HidMouseReport.parse(bytes( + "05 01 09 02 a1 01 85 01 09 01 a1 00 05 09 19 01 29 05 15 00 25 01 75 01 95 05 81 02 75 03 95 01 81 01 " + + "05 01 09 30 09 31 15 81 25 7f 75 08 95 02 81 06 09 38 15 81 25 7f 75 08 95 01 81 06 c0 05 0c 15 81 25 7f " + + "75 08 95 01 0a 38 02 81 06 c0 05 0c 09 01 a1 01 85 03 19 00 2a 80 03 15 00 26 80 03 75 10 95 01 81 00 c0 " + + "05 01 09 80 a1 01 85 02 19 81 29 83 25 01 75 01 95 03 81 02 95 05 81 01 c0 06 f2 f1 0a f2 f1 a1 01 85 05 " + + "09 00 95 06 75 08 15 00 26 ff 00 91 02 09 00 95 05 75 08 15 00 26 ff 00 81 02 c0"))!! + + @Test fun readsTheReceiversMouseReport() { + assertEquals(1, receiver.reportId) + assertEquals(HidMouseReport.State(0, 5, -7, 0), receiver.decode("01 00 05 f9 00 00")) + assertEquals(HidMouseReport.State(0, -30, -2, 0), receiver.decode("01 00 e2 fe 00 00")) + } + + @Test fun readsButtonsAndWheel() { + assertEquals(HidMouseReport.State(0b10, 0, 0, 0), receiver.decode("01 02 00 00 00 00")) + assertEquals(HidMouseReport.State(0b11111, 0, 0, 0), receiver.decode("01 1f 00 00 00 00")) + assertEquals(HidMouseReport.State(0, 0, 0, -1), receiver.decode("01 00 00 00 ff 00")) + } + + @Test fun ignoresTheReceiversOtherReports() { + assertNull(receiver.decode("03 e9 00")) + assertNull(receiver.decode("02 01")) + } + + @Test fun readsSixteenBitMotionWithoutReportIds() { + val mouse = HidMouseReport.parse(bytes( + "05 01 09 02 a1 01 09 01 a1 00 05 09 19 01 29 05 15 00 25 01 95 05 75 01 81 02 95 01 75 03 81 01 " + + "05 01 16 01 80 26 ff 7f 75 10 95 02 09 30 09 31 81 06 15 81 25 7f 75 08 95 01 09 38 81 06 c0 c0")) + assertNotNull(mouse) + assertEquals(0, mouse!!.reportId) + assertEquals(HidMouseReport.State(1, 300, -100, 1), mouse.decode("01 2c 01 9c ff 01")) + } + + @Test fun findsNoMouseInAKeyboard() { + assertNull(HidMouseReport.parse(bytes("05 01 09 06 a1 01 05 07 19 e0 29 e7 15 00 25 01 75 01 95 08 81 02 c0"))) + } + + @Test fun rejectsOutOfRangeReportCountsAndSizes() { + assertNull(HidMouseReport.parse(bytes( + "05 01 09 02 a1 01 05 09 19 01 29 03 15 00 25 01 75 01 96 01 10 81 02 " + + "05 01 09 30 09 31 15 81 25 7f 75 08 95 02 81 06 c0"))) + assertNotNull(HidMouseReport.parse(bytes( + "05 01 09 02 a1 01 05 09 19 01 29 03 15 00 25 01 75 01 96 00 10 81 02 " + + "05 01 09 30 09 31 15 81 25 7f 75 08 95 02 81 06 c0"))) + assertNull(HidMouseReport.parse(bytes( + "05 01 09 02 a1 01 05 01 09 30 09 31 15 81 25 7f 77 ff ff ff 7f 95 02 81 06 c0"))) + } + + @Test fun readsTheBootReport() { + assertEquals(HidMouseReport.State(0b11, -6, 2, 0), HidMouseReport.BOOT.decode("03 fa 02")) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/input/InputSpaceTest.kt b/app/src/test/java/com/droiddeck/launcher/input/InputSpaceTest.kt index c8c63c0444..fa7d043028 100644 --- a/app/src/test/java/com/droiddeck/launcher/input/InputSpaceTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/input/InputSpaceTest.kt @@ -40,4 +40,14 @@ class InputSpaceTest { assertEquals(InputSpace.HEIGHT - 1, InputSpace.y(5000f, 1504)) assertEquals(0, InputSpace.y(10f, 0)) } + + @Test fun fixedPositionsKeepTheFractionOfAnInputUnit() { + assertEquals(960 * 256, InputSpace.fixedX(1200f, 2400)) + assertEquals(1700, InputSpace.fixedX(5.534f, 1600)) + assertEquals(InputSpace.x(5.534f, 1600), InputSpace.fixedX(5.534f, 1600) / InputSpace.FIXED_ONE) + assertEquals(InputSpace.WIDTH * InputSpace.FIXED_ONE - 1, InputSpace.fixedX(2400f, 2400)) + assertEquals(InputSpace.HEIGHT * InputSpace.FIXED_ONE - 1, InputSpace.fixedY(5000f, 1504)) + assertEquals(0, InputSpace.fixedY(-1f, 1504)) + assertEquals(0, InputSpace.fixedY(10f, 0)) + } } diff --git a/app/src/test/java/com/droiddeck/launcher/input/MouseBackInputTest.kt b/app/src/test/java/com/droiddeck/launcher/input/MouseBackInputTest.kt index ba7e666c6c..41f5db5b13 100644 --- a/app/src/test/java/com/droiddeck/launcher/input/MouseBackInputTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/input/MouseBackInputTest.kt @@ -195,4 +195,16 @@ class MouseBackInputTest { assertTrue(external.onKeyEvent(injected(KeyEvent.ACTION_DOWN), toGuest = true)) assertEquals(listOf(true), presses) } + + @Test fun aControllersOwnMouseInterfaceDoesNotCount() { + fun usb(id: Int, name: String, sources: Int, product: Int) = InputDeviceBuilder.newBuilder().setId(id).setName(name) + .setDescriptor("$name-$id").setExternal(true).setSources(sources).setVendorId(0x2dc8).setProductId(product).build() + val padMouse = usb(26, "8BitDo Ultimate Mobile Gaming Controller", 0x20004, 0x301f) + val pad = usb(28, "8BitDo Ultimate Mobile Gaming Controller", 0x1000511, 0x301f) + val mouse = usb(30, "8BitDo Retro R8 Mouse", InputDevice.SOURCE_MOUSE, 0x5200) + assertTrue(MouseBackInput.isExternalMouse(padMouse)) + assertNull(MouseBackInput.externalMouse(listOf(padMouse, pad, null))) + assertSame(padMouse, MouseBackInput.externalMouse(listOf(padMouse))) + assertSame(mouse, MouseBackInput.externalMouse(listOf(padMouse, pad, mouse))) + } } diff --git a/app/src/test/java/com/droiddeck/launcher/input/MouseMenuHoldTest.kt b/app/src/test/java/com/droiddeck/launcher/input/MouseMenuHoldTest.kt new file mode 100644 index 0000000000..77377ccc6e --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/input/MouseMenuHoldTest.kt @@ -0,0 +1,54 @@ +package com.droiddeck.launcher.input + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test + +class MouseMenuHoldTest { + private var pending: Runnable? = null + private var delay = 0L + private var menus = 0 + private val hold = MouseMenuHold( + schedule = { runnable, ms -> pending = runnable; delay = ms }, + cancel = { if (pending === it) pending = null }, + onMenu = { menus++ }, + ) + + private fun elapse() = pending?.also { pending = null }?.run() + + @Test fun holdingTheMiddleButtonStillOpensTheMenu() { + hold.onButton(MouseMenuHold.MIDDLE, true) + assertEquals(MouseMenuHold.HOLD_MS, delay) + hold.onMove(3, -2) + elapse() + assertEquals(1, menus) + } + + @Test fun aQuickMiddleClickDoesNothing() { + hold.onButton(MouseMenuHold.MIDDLE, true) + hold.onButton(MouseMenuHold.MIDDLE, false) + assertNull(pending) + assertEquals(0, menus) + } + + @Test fun draggingWithTheMiddleButtonDoesNothing() { + hold.onButton(MouseMenuHold.MIDDLE, true) + hold.onMove(30, 0) + hold.onMove(0, -30) + assertNull(pending) + assertEquals(0, menus) + } + + @Test fun otherButtonsDoNothing() { + hold.onButton(0, true) + hold.onButton(1, true) + assertNull(pending) + } + + @Test fun resetCancelsAHold() { + hold.onButton(MouseMenuHold.MIDDLE, true) + hold.reset() + assertNull(pending) + assertEquals(0, menus) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/input/PenRouterTest.kt b/app/src/test/java/com/droiddeck/launcher/input/PenRouterTest.kt new file mode 100644 index 0000000000..6347a4470c --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/input/PenRouterTest.kt @@ -0,0 +1,27 @@ +package com.droiddeck.launcher.input + +import com.droiddeck.launcher.session.SessionPrefs +import org.junit.Assert.assertEquals +import org.junit.Test + +class PenRouterTest { + @Test fun appUiBlocksThePenInEveryModeAndScreen() { + for (mode in listOf(SessionPrefs.PEN_MOUSE, SessionPrefs.PEN_TOUCH)) + for (glasses in listOf(false, true)) for (lock in listOf(false, true)) + assertEquals("$mode $glasses $lock", PenRouter.Route.BLOCKED, PenRouter.decide(true, mode, glasses, lock)) + } + + @Test fun touchModeKeepsThePenAFingerEverywhere() { + for (glasses in listOf(false, true)) for (lock in listOf(false, true)) + assertEquals("$glasses $lock", PenRouter.Route.TOUCH, PenRouter.decide(false, SessionPrefs.PEN_TOUCH, glasses, lock)) + } + + @Test fun glassesAndProgramLocksMakeTheMouseRelative() { + for ((glasses, lock) in listOf(true to false, false to true, true to true)) + assertEquals("$glasses $lock", PenRouter.Route.RELATIVE, PenRouter.decide(false, SessionPrefs.PEN_MOUSE, glasses, lock)) + } + + @Test fun mouseDrivesThePenRouteOnThePhone() { + assertEquals(PenRouter.Route.PEN, PenRouter.decide(false, SessionPrefs.PEN_MOUSE, false, false)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/input/PenStreamTest.kt b/app/src/test/java/com/droiddeck/launcher/input/PenStreamTest.kt new file mode 100644 index 0000000000..69ee6a636f --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/input/PenStreamTest.kt @@ -0,0 +1,384 @@ +package com.droiddeck.launcher.input + +import android.graphics.RectF +import android.os.Looper +import android.os.SystemClock +import android.view.InputDevice +import android.view.KeyEvent +import android.view.MotionEvent +import com.droiddeck.launcher.input.PenStream.Companion.PEN_IN +import com.droiddeck.launcher.input.PenStream.Companion.PEN_MIDDLE +import com.droiddeck.launcher.input.PenStream.Companion.PEN_RIGHT +import com.droiddeck.launcher.input.PenStream.Companion.PEN_TIP +import com.droiddeck.launcher.session.SessionPrefs +import java.time.Duration +import org.junit.Assert.* +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE) +class PenStreamTest { + data class Record(val flags: Int, val x: Int, val y: Int) + data class Sample(val time: Long, val x: Float, val y: Float = 300f) + + private val records = mutableListOf() + private val stream = PenStream { flags, x, y -> records += Record(flags, x, y) } + private val area = RectF(0f, 0f, 1000f, 600f) + + @Test fun hoverEntersMovesAndLeavesProximity() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(10, 100f)) + send(MotionEvent.ACTION_HOVER_MOVE, Sample(20, 200f)) + send(MotionEvent.ACTION_HOVER_EXIT, Sample(30, 250f)) + assertEquals(listOf(PEN_IN, PEN_IN), flags()) + idle() + assertEquals(listOf(PEN_IN, PEN_IN), flags()) + grace() + assertEquals(listOf(PEN_IN, PEN_IN, 0), flags()) + assertEquals(listOf(100f, 200f).map(::x), records.take(2).map { it.x }) + assertFalse(stream.inProximity) + } + + @Test fun hoverExitThenDownWithTheSameTimeStaysInProximity() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(10, 100f)) + send(MotionEvent.ACTION_HOVER_EXIT, Sample(20, 100f)) + send(MotionEvent.ACTION_DOWN, Sample(20, 100f)) + grace() + assertEquals(listOf(PEN_IN, PEN_IN or PEN_TIP), flags()) + } + + @Test fun hoverExitThenADownAfterTheGraceLeavesProximityFirst() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(10, 100f)) + send(MotionEvent.ACTION_HOVER_EXIT, Sample(20, 100f)) + send(MotionEvent.ACTION_DOWN, Sample(21 + PenStream.EXIT_GRACE_MS, 100f)) + assertEquals(listOf(PEN_IN, 0, PEN_IN or PEN_TIP), flags()) + } + + @Test fun aPenFlickeringAtTheEdgeOfHoverRangeStaysInProximity() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(10, 100f)) + for (i in 0 until 5) { + send(MotionEvent.ACTION_HOVER_EXIT, Sample(20L + i * 22, 100f)) + send(MotionEvent.ACTION_HOVER_ENTER, Sample(34L + i * 22, 101f)) + } + send(MotionEvent.ACTION_HOVER_EXIT, Sample(130, 101f)) + send(MotionEvent.ACTION_DOWN, Sample(130 + PenStream.EXIT_GRACE_MS, 101f)) + grace() + assertEquals(List(6) { PEN_IN } + (PEN_IN or PEN_TIP), flags()) + assertTrue(stream.inProximity) + } + + @Test fun liftingIntoHoverKeepsProximityAndLiftingAwayLeavesIt() { + send(MotionEvent.ACTION_DOWN, Sample(10, 100f)) + send(MotionEvent.ACTION_UP, Sample(20, 110f)) + send(MotionEvent.ACTION_HOVER_ENTER, Sample(20, 110f)) + grace() + assertEquals(listOf(PEN_IN or PEN_TIP, PEN_IN, PEN_IN), flags()) + records.clear() + send(MotionEvent.ACTION_DOWN, Sample(30, 100f)) + send(MotionEvent.ACTION_UP, Sample(40, 100f)) + grace() + assertEquals(listOf(PEN_IN or PEN_TIP, PEN_IN, 0), flags()) + } + + @Test fun aPenKeyDuringTheExitGraceEndsProximityFirst() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(10, 100f)) + send(MotionEvent.ACTION_HOVER_EXIT, Sample(20, 100f)) + assertTrue(stream.onKey(key(KeyEvent.ACTION_DOWN, 25))) + grace() + assertEquals(listOf(PEN_IN, 0), flags()) + } + + @Test fun historicalSamplesGoOutOldestFirst() { + send(MotionEvent.ACTION_DOWN, Sample(100, 10f)) + send(MotionEvent.ACTION_MOVE, Sample(103, 20f), Sample(106, 30f), Sample(109, 40f)) + assertEquals(listOf(10f, 20f, 30f, 40f).map(::x), records.map { it.x }) + assertTrue(records.all { it.flags == PEN_IN or PEN_TIP }) + assertEquals(y(300f), records.last().y) + } + + @Test fun cancelEndsTheStrokeAndIgnoresTheRest() { + send(MotionEvent.ACTION_DOWN, Sample(10, 100f)) + send(MotionEvent.ACTION_MOVE, Sample(20, 150f)) + send(MotionEvent.ACTION_CANCEL, Sample(30, 160f)) + send(MotionEvent.ACTION_MOVE, Sample(40, 170f)) + send(MotionEvent.ACTION_UP, Sample(50, 170f)) + assertEquals(listOf(PEN_IN or PEN_TIP, PEN_IN or PEN_TIP, 0), flags()) + assertFalse(stream.inProximity) + } + + @Test fun anUpThatAndroidCanceledIsACancelNotALift() { + send(MotionEvent.ACTION_DOWN, Sample(10, 100f)) + send(MotionEvent.ACTION_UP, Sample(20, 100f), flags = MotionEvent.FLAG_CANCELED) + assertEquals(listOf(PEN_IN or PEN_TIP, 0), flags()) + } + + @Test fun theSideButtonSettingMapsThePrimaryButtonAndTheSecondaryGetsTheOtherClick() { + val cases = mapOf(SessionPrefs.PEN_BUTTON_RIGHT to (PEN_RIGHT to PEN_MIDDLE), + SessionPrefs.PEN_BUTTON_MIDDLE to (PEN_MIDDLE to PEN_RIGHT), SessionPrefs.PEN_BUTTON_OFF to (0 to PEN_RIGHT)) + for ((setting, expected) in cases) { + assertEquals(setting, 0, PenStream.buttonFlags(primary = false, secondary = false, sideButton = setting)) + assertEquals(setting, expected.first, PenStream.buttonFlags(primary = true, secondary = false, sideButton = setting)) + assertEquals(setting, expected.second, PenStream.buttonFlags(primary = false, secondary = true, sideButton = setting)) + assertEquals(setting, expected.first or expected.second, PenStream.buttonFlags(primary = true, secondary = true, sideButton = setting)) + } + stream.sideButton = SessionPrefs.PEN_BUTTON_MIDDLE + send(MotionEvent.ACTION_HOVER_ENTER, Sample(10, 100f), buttons = MotionEvent.BUTTON_STYLUS_PRIMARY) + send(MotionEvent.ACTION_HOVER_MOVE, Sample(20, 100f), buttons = MotionEvent.BUTTON_STYLUS_SECONDARY) + assertEquals(listOf(PEN_IN or PEN_MIDDLE, PEN_IN or PEN_RIGHT), flags()) + } + + @Test fun barrelButtonsFollowTheButtonState() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(10, 100f)) + send(MotionEvent.ACTION_HOVER_MOVE, Sample(20, 100f), buttons = MotionEvent.BUTTON_STYLUS_PRIMARY) + send(MotionEvent.ACTION_BUTTON_PRESS, Sample(21, 100f), buttons = MotionEvent.BUTTON_STYLUS_PRIMARY or MotionEvent.BUTTON_STYLUS_SECONDARY) + send(MotionEvent.ACTION_DOWN, Sample(30, 100f), buttons = MotionEvent.BUTTON_STYLUS_SECONDARY) + send(MotionEvent.ACTION_MOVE, Sample(40, 100f)) + assertEquals(listOf(PEN_IN, PEN_IN or PEN_RIGHT, PEN_IN or PEN_RIGHT or PEN_MIDDLE, PEN_IN or PEN_TIP or PEN_MIDDLE, + PEN_IN or PEN_TIP), flags()) + } + + @Test fun aBluetoothPenKeyIsTheSideButtonWhileThePenIsNear() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(10, 100f)) + assertTrue(stream.onKey(key(KeyEvent.ACTION_DOWN, 15))) + assertTrue(stream.onKey(key(KeyEvent.ACTION_DOWN, 16, repeat = 1))) + send(MotionEvent.ACTION_HOVER_MOVE, Sample(20, 130f)) + assertTrue(stream.onKey(key(KeyEvent.ACTION_UP, 25))) + stream.cancel() + stream.sideButton = SessionPrefs.PEN_BUTTON_MIDDLE + send(MotionEvent.ACTION_HOVER_ENTER, Sample(30, 100f)) + stream.onKey(key(KeyEvent.ACTION_DOWN, 35)) + stream.onKey(key(KeyEvent.ACTION_UP, 36)) + stream.cancel() + assertEquals(listOf(PEN_IN, PEN_IN or PEN_RIGHT, PEN_IN or PEN_RIGHT, PEN_IN, 0, + PEN_IN, PEN_IN or PEN_MIDDLE, PEN_IN, 0), flags()) + assertEquals(x(130f), records[2].x) + records.clear() + stream.sideButton = SessionPrefs.PEN_BUTTON_OFF + send(MotionEvent.ACTION_HOVER_ENTER, Sample(40, 100f)) + assertTrue(stream.onKey(key(KeyEvent.ACTION_DOWN, 45))) + assertTrue(stream.holdsKey(key(KeyEvent.ACTION_UP, 46))) + assertTrue(stream.onKey(key(KeyEvent.ACTION_UP, 46))) + assertEquals(listOf(PEN_IN), flags()) + } + + @Test fun aBluetoothPenKeyIsConsumedWhenThePenIsAway() { + assertTrue(stream.onKey(key(KeyEvent.ACTION_DOWN, 10))) + send(MotionEvent.ACTION_HOVER_ENTER, Sample(20, 100f)) + assertTrue(stream.onKey(key(KeyEvent.ACTION_UP, 30))) + assertEquals(listOf(PEN_IN), flags()) + } + + @Test fun aKeyHeldWhileThePenIsAwayIsReleasedAndPressedAgainOnReturn() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(10, 100f)) + stream.onKey(key(KeyEvent.ACTION_DOWN, 15)) + send(MotionEvent.ACTION_HOVER_EXIT, Sample(20, 100f)) + grace() + stream.onKey(key(KeyEvent.ACTION_DOWN, 500, repeat = 1)) + stream.onKey(key(KeyEvent.ACTION_DOWN, 550, repeat = 2)) + send(MotionEvent.ACTION_HOVER_ENTER, Sample(600, 100f)) + send(MotionEvent.ACTION_DOWN, Sample(610, 100f)) + send(MotionEvent.ACTION_UP, Sample(620, 100f)) + send(MotionEvent.ACTION_HOVER_ENTER, Sample(620, 100f)) + stream.onKey(key(KeyEvent.ACTION_UP, 630)) + val right = PEN_IN or PEN_RIGHT + assertEquals(listOf(PEN_IN, right, 0, right, right or PEN_TIP, right, right, PEN_IN), flags()) + } + + @Test fun aKeyReleasedWhileThePenIsAwayStaysReleased() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(10, 100f)) + stream.onKey(key(KeyEvent.ACTION_DOWN, 15)) + send(MotionEvent.ACTION_HOVER_EXIT, Sample(20, 100f)) + grace() + assertTrue(stream.holdsKey(key(KeyEvent.ACTION_UP, 40))) + assertTrue(stream.onKey(key(KeyEvent.ACTION_UP, 40))) + assertFalse(stream.holdsKey(key(KeyEvent.ACTION_UP, 41))) + send(MotionEvent.ACTION_HOVER_ENTER, Sample(50, 100f)) + assertEquals(listOf(PEN_IN, PEN_IN or PEN_RIGHT, 0, PEN_IN), flags()) + } + + @Test fun onlyALifecycleCancelForgetsAHeldKeyAndARepeatBringsItBack() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(10, 100f)) + stream.onKey(key(KeyEvent.ACTION_DOWN, 15)) + stream.cancel() + send(MotionEvent.ACTION_HOVER_ENTER, Sample(20, 100f)) + stream.cancel(releaseKey = true) + send(MotionEvent.ACTION_HOVER_ENTER, Sample(30, 100f)) + assertFalse(stream.holdsKey(key(KeyEvent.ACTION_UP, 35))) + stream.onKey(key(KeyEvent.ACTION_DOWN, 40, repeat = 1)) + stream.onKey(key(KeyEvent.ACTION_UP, 50)) + val right = PEN_IN or PEN_RIGHT + assertEquals(listOf(PEN_IN, right, 0, right, 0, PEN_IN, right, PEN_IN), flags()) + } + + @Test fun removingTheBluetoothPenReleasesItsKeyAndForgetsIt() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(10, 100f)) + stream.onKey(key(KeyEvent.ACTION_DOWN, 15)) + stream.deviceRemoved(10) + assertFalse(stream.holdsKey(key(KeyEvent.ACTION_UP, 18))) + assertTrue(stream.inProximity) + stream.onKey(key(KeyEvent.ACTION_DOWN, 20)) + send(MotionEvent.ACTION_HOVER_EXIT, Sample(25, 100f)) + grace() + stream.deviceRemoved(10) + send(MotionEvent.ACTION_HOVER_ENTER, Sample(30, 100f)) + assertEquals(listOf(PEN_IN, PEN_IN or PEN_RIGHT, PEN_IN, PEN_IN or PEN_RIGHT, 0, PEN_IN), flags()) + } + + @Test fun aHoverThatStopsReportingCountsAsGone() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(1_000, 100f)) + send(MotionEvent.ACTION_HOVER_MOVE, Sample(2_000, 100f)) + send(MotionEvent.ACTION_HOVER_MOVE, Sample(4_500, 110f)) + assertEquals(listOf(PEN_IN, PEN_IN, 0, PEN_IN), flags()) + records.clear() + assertTrue(stream.onKey(key(KeyEvent.ACTION_DOWN, 7_000))) + assertEquals(listOf(0), flags()) + } + + @Test fun aPenKeyDoesNotKeepASilentHoverNear() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(1_000, 100f)) + assertTrue(stream.onKey(key(KeyEvent.ACTION_DOWN, 2_500))) + assertTrue(stream.onKey(key(KeyEvent.ACTION_UP, 3_000))) + assertEquals(listOf(PEN_IN, PEN_IN or PEN_RIGHT, 0), flags()) + } + + @Test fun aSilentHoverIsSentOutByTheWatchdogWithoutAnotherEvent() { + val start = SystemClock.uptimeMillis() + send(MotionEvent.ACTION_HOVER_ENTER, Sample(start, 100f), buttons = MotionEvent.BUTTON_STYLUS_PRIMARY) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(1_500)) + send(MotionEvent.ACTION_HOVER_MOVE, Sample(start + 1_500, 110f), buttons = MotionEvent.BUTTON_STYLUS_PRIMARY) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(PenStream.HOVER_TIMEOUT_MS - 1)) + assertTrue(stream.inProximity) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(1)) + assertFalse(stream.inProximity) + assertEquals(listOf(PEN_IN or PEN_RIGHT, PEN_IN or PEN_RIGHT, 0), flags()) + } + + @Test fun theWatchdogNeverEndsAContact() { + val start = SystemClock.uptimeMillis() + send(MotionEvent.ACTION_HOVER_ENTER, Sample(start, 100f)) + send(MotionEvent.ACTION_DOWN, Sample(start + 10, 100f)) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(5)) + assertTrue(stream.inProximity) + assertEquals(listOf(PEN_IN, PEN_IN or PEN_TIP), flags()) + } + + @Test fun aStrokeIsNeverTimedOut() { + send(MotionEvent.ACTION_DOWN, Sample(1_000, 100f)) + send(MotionEvent.ACTION_MOVE, Sample(9_000, 110f)) + assertEquals(listOf(PEN_IN or PEN_TIP, PEN_IN or PEN_TIP), flags()) + } + + @Test fun lifecycleCancelEndsEverythingOnce() { + send(MotionEvent.ACTION_DOWN, Sample(10, 100f)) + stream.cancel() + stream.cancel() + assertEquals(listOf(PEN_IN or PEN_TIP, 0), flags()) + } + + @Test fun removingThePenDeviceEndsItsStream() { + send(MotionEvent.ACTION_HOVER_ENTER, Sample(10, 100f), device = 6) + stream.deviceRemoved(8) + assertTrue(stream.inProximity) + stream.deviceRemoved(6) + assertEquals(listOf(PEN_IN, 0), flags()) + } + + @Test fun aPenNextToAFingerKeepsItsOwnStroke() { + val finger = MotionEvent.TOOL_TYPE_FINGER + val stylus = MotionEvent.TOOL_TYPE_STYLUS + mixed(MotionEvent.ACTION_DOWN, 10, finger to 50f) + assertTrue(records.isEmpty()) + mixed(MotionEvent.ACTION_POINTER_DOWN or (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT), 20, finger to 50f, stylus to 400f) + mixed(MotionEvent.ACTION_MOVE, 30, finger to 60f, stylus to 410f) + mixed(MotionEvent.ACTION_POINTER_UP, 40, finger to 60f, stylus to 420f) + mixed(MotionEvent.ACTION_POINTER_UP or (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT), 50, finger to 60f, stylus to 430f) + assertEquals(listOf(PEN_IN or PEN_TIP, PEN_IN or PEN_TIP, PEN_IN or PEN_TIP, PEN_IN), flags()) + assertEquals(listOf(400f, 410f, 420f, 430f).map(::x), records.map { it.x }) + } + + @Test fun positionsAreClampedToThePicture() { + val event = event(MotionEvent.ACTION_HOVER_ENTER, listOf(Sample(10, 40f, y = 580f)), MotionEvent.TOOL_TYPE_STYLUS) + try { stream.onMotion(event, 0, RectF(100f, 50f, 900f, 550f), 1000, 600) } finally { event.recycle() } + assertEquals(Record(PEN_IN, x(100f), y(550f)), records.single()) + } + + @Test fun pensAreFoundByToolTypeFirstAndSourceSecond() { + fun index(tool: Int, source: Int): Int { + val event = event(MotionEvent.ACTION_DOWN, listOf(Sample(0, 1f)), tool, source = source) + return try { PenStream.penIndex(event) } finally { event.recycle() } + } + assertEquals(0, index(MotionEvent.TOOL_TYPE_STYLUS, InputDevice.SOURCE_MOUSE)) + assertEquals(0, index(MotionEvent.TOOL_TYPE_ERASER, InputDevice.SOURCE_TOUCHSCREEN)) + assertEquals(0, index(MotionEvent.TOOL_TYPE_UNKNOWN, InputDevice.SOURCE_STYLUS)) + assertEquals(-1, index(MotionEvent.TOOL_TYPE_FINGER, InputDevice.SOURCE_STYLUS)) + assertEquals(-1, index(MotionEvent.TOOL_TYPE_MOUSE, InputDevice.SOURCE_MOUSE or InputDevice.SOURCE_STYLUS)) + assertEquals(-1, index(MotionEvent.TOOL_TYPE_UNKNOWN, InputDevice.SOURCE_TOUCHSCREEN)) + } + + @Test fun penButtonKeyboardsAreRecognisedByNameAndShape() { + val keyboard = InputDevice.SOURCE_KEYBOARD + assertTrue(PenStream.isPenKeyboard("OPPO AI Pen", keyboard, external = true, alphabetic = false)) + assertTrue(PenStream.isPenKeyboard("Xiaomi Smart STYLUS", keyboard, external = true, alphabetic = false)) + assertTrue(PenStream.isPenKeyboard("HUAWEI M-Pencil", keyboard, external = true, alphabetic = false)) + assertFalse(PenStream.isPenKeyboard("OPPO AI Pen", keyboard, external = false, alphabetic = false)) + assertFalse(PenStream.isPenKeyboard("OPPO AI Pen", keyboard or InputDevice.SOURCE_MOUSE, external = true, alphabetic = false)) + assertFalse(PenStream.isPenKeyboard("Pen Keyboard K380", keyboard, external = true, alphabetic = true)) + assertFalse(PenStream.isPenKeyboard("Open Remote", keyboard, external = true, alphabetic = false)) + assertFalse(PenStream.isPenKeyboard("8BitDo Remote", keyboard, external = true, alphabetic = false)) + assertFalse(PenStream.isPenKeyboard(null, keyboard, external = true, alphabetic = false)) + } + + @Test fun aTouchscreenCountsAsAPenDeviceOnlyWhereAndroidSetsTheStylusBitForPens() { + val screen = InputDevice.SOURCE_TOUCHSCREEN or InputDevice.SOURCE_STYLUS + assertFalse(PenStream.isPenDevice(screen, sdk = 33)) + assertTrue(PenStream.isPenDevice(screen, sdk = 34)) + for (sdk in listOf(26, 33, 34)) { + assertTrue(PenStream.isPenDevice(InputDevice.SOURCE_MOUSE or InputDevice.SOURCE_STYLUS, sdk)) + assertTrue(PenStream.isPenDevice(InputDevice.SOURCE_BLUETOOTH_STYLUS, sdk)) + assertTrue(PenStream.isPenDevice(InputDevice.SOURCE_STYLUS, sdk)) + assertFalse(PenStream.isPenDevice(InputDevice.SOURCE_TOUCHSCREEN, sdk)) + assertFalse(PenStream.isPenDevice(InputDevice.SOURCE_MOUSE, sdk)) + } + } + + private fun flags() = records.map { it.flags } + private fun x(position: Float) = InputSpace.fixedX(position, 1000) + private fun y(position: Float) = InputSpace.fixedY(position, 600) + private fun idle() = shadowOf(Looper.getMainLooper()).idle() + private fun grace() = shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(PenStream.EXIT_GRACE_MS)) + + private fun key(action: Int, time: Long, repeat: Int = 0) = + KeyEvent(time, time, action, KeyEvent.KEYCODE_UNKNOWN, repeat, 0, 10, 191, 0, InputDevice.SOURCE_KEYBOARD) + + private fun send(action: Int, vararg samples: Sample, buttons: Int = 0, flags: Int = 0, device: Int = 6) { + val event = event(action, samples.toList(), MotionEvent.TOOL_TYPE_STYLUS, buttons, flags, device = device) + try { stream.onMotion(event, 0, area, 1000, 600) } finally { event.recycle() } + } + + private fun mixed(action: Int, time: Long, vararg pointers: Pair) { + val properties = Array(pointers.size) { MotionEvent.PointerProperties().apply { id = it; toolType = pointers[it].first } } + val coords = Array(pointers.size) { MotionEvent.PointerCoords().apply { x = pointers[it].second; y = 300f; pressure = 0.5f } } + val event = MotionEvent.obtain(0, time, action, pointers.size, properties, coords, 0, 0, 1f, 1f, 6, 0, + InputDevice.SOURCE_TOUCHSCREEN or InputDevice.SOURCE_STYLUS, 0) + try { + val pen = PenStream.penIndex(event) + if (pen >= 0) stream.onMotion(event, pen, area, 1000, 600) + } finally { event.recycle() } + } + + private fun event(action: Int, samples: List, tool: Int, buttons: Int = 0, flags: Int = 0, + source: Int = InputDevice.SOURCE_TOUCHSCREEN or InputDevice.SOURCE_STYLUS, device: Int = 6): MotionEvent { + val properties = arrayOf(MotionEvent.PointerProperties().apply { id = 0; toolType = tool }) + fun coords(sample: Sample) = arrayOf(MotionEvent.PointerCoords().apply { + x = sample.x + y = sample.y + }) + val first = samples.first() + val event = MotionEvent.obtain(0, first.time, action, 1, properties, coords(first), 0, buttons, 1f, 1f, device, 0, source, flags) + for (sample in samples.drop(1)) event.addBatch(sample.time, coords(sample), 0) + return event + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/input/PointerSubsetTest.kt b/app/src/test/java/com/droiddeck/launcher/input/PointerSubsetTest.kt new file mode 100644 index 0000000000..8326c1b26a --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/input/PointerSubsetTest.kt @@ -0,0 +1,57 @@ +package com.droiddeck.launcher.input + +import android.view.InputDevice +import android.view.MotionEvent +import org.junit.Assert.* +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE) +class PointerSubsetTest { + @Test fun aForwardedPointerKeepsItsHistoryAndTimes() { + val properties = Array(2) { MotionEvent.PointerProperties().apply { id = it; toolType = if (it == 0) MotionEvent.TOOL_TYPE_FINGER else MotionEvent.TOOL_TYPE_STYLUS } } + fun coords(step: Int) = Array(2) { MotionEvent.PointerCoords().apply { x = 100f * it + step; y = 50f; pressure = 0.1f * step } } + val event = MotionEvent.obtain(5, 10, MotionEvent.ACTION_MOVE, 2, properties, coords(1), 0, 0, 1f, 1f, 3, 0, + InputDevice.SOURCE_TOUCHSCREEN or InputDevice.SOURCE_STYLUS, MotionEvent.FLAG_CANCELED) + event.addBatch(14, coords(2), 0) + event.addBatch(18, coords(3), 0) + val split = event.pointerSubset(1 shl 1)!! + try { + assertEquals(1, split.pointerCount) + assertEquals(MotionEvent.TOOL_TYPE_STYLUS, split.getToolType(0)) + assertEquals(2, split.historySize) + assertEquals(listOf(10L, 14L), (0 until split.historySize).map { split.getHistoricalEventTime(it) }) + assertEquals(listOf(101f, 102f), (0 until split.historySize).map { split.getHistoricalX(0, it) }) + assertEquals(0.2f, split.getHistoricalPressure(0, 1), 1e-6f) + assertEquals(18L, split.eventTime) + assertEquals(103f, split.x, 0f) + assertEquals(5L, split.downTime) + assertEquals(MotionEvent.ACTION_MOVE, split.actionMasked) + assertEquals(event.source, split.source) + assertEquals(MotionEvent.FLAG_CANCELED, split.flags and MotionEvent.FLAG_CANCELED) + } finally { + split.recycle() + event.recycle() + } + } + + @Test fun anEventWithoutHistoryStaysASingleSample() { + val properties = arrayOf(MotionEvent.PointerProperties().apply { id = 2; toolType = MotionEvent.TOOL_TYPE_FINGER }) + val coords = arrayOf(MotionEvent.PointerCoords().apply { x = 7f; y = 8f }) + val event = MotionEvent.obtain(0, 20, MotionEvent.ACTION_DOWN, 1, properties, coords, 0, 0, 1f, 1f, 0, 0, InputDevice.SOURCE_TOUCHSCREEN, 0) + val split = event.pointerSubset(1 shl 2)!! + try { + assertEquals(0, split.historySize) + assertEquals(20L, split.eventTime) + assertEquals(MotionEvent.ACTION_DOWN, split.actionMasked) + assertEquals(7f, split.x, 0f) + assertNull(event.pointerSubset(1 shl 0)) + } finally { + split.recycle() + event.recycle() + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/input/SessionPenRoutingTest.kt b/app/src/test/java/com/droiddeck/launcher/input/SessionPenRoutingTest.kt new file mode 100644 index 0000000000..cd6a40bc24 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/input/SessionPenRoutingTest.kt @@ -0,0 +1,426 @@ +package com.droiddeck.launcher.input + +import android.hardware.input.InputManager +import android.os.Looper +import android.view.InputDevice +import android.view.KeyEvent +import android.view.MotionEvent +import android.view.SurfaceView +import androidx.compose.runtime.MutableState +import androidx.compose.ui.geometry.Offset +import com.droiddeck.launcher.SessionActivity +import com.droiddeck.launcher.input.PenStream.Companion.PEN_IN +import com.droiddeck.launcher.input.PenStream.Companion.PEN_MIDDLE +import com.droiddeck.launcher.input.PenStream.Companion.PEN_RIGHT +import com.droiddeck.launcher.input.PenStream.Companion.PEN_TIP +import com.droiddeck.launcher.session.SessionPrefs +import com.droiddeck.launcher.session.SessionService +import com.droiddeck.launcher.session.SessionState +import com.droiddeck.launcher.wayland.WaylandCompositor +import java.time.Duration +import org.junit.After +import org.junit.Assert.* +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config +import org.robolectric.annotation.Implementation +import org.robolectric.annotation.Implements +import org.robolectric.shadows.InputDeviceBuilder +import org.robolectric.shadows.ShadowInputDevice +import org.robolectric.util.ReflectionHelpers + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE, shadows = [SessionPenRoutingTest.CompositorShadow::class]) +class SessionPenRoutingTest { + private lateinit var activity: SessionActivity + private val previousSize = SessionState.outputSize + private val previousMode = SessionState.mode + private val previousSteamUi = SessionState.steamUi + private val pen = MotionEvent.TOOL_TYPE_STYLUS + private val finger = MotionEvent.TOOL_TYPE_FINGER + private val stylusScreen = InputDevice.SOURCE_TOUCHSCREEN or InputDevice.SOURCE_STYLUS + + @Before fun setUp() { + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(2)) + activity = Robolectric.buildActivity(SessionActivity::class.java).get() + activity.window.decorView + activity.getSharedPreferences("session", 0).edit().clear().commit() + field("surfaceView", SurfaceView(activity).apply { layout(0, 0, 1000, 600) }) + SessionState.outputSize = 1000 to 600 + SessionState.mode = SessionService.MODE_DESKTOP + SessionState.steamUi = null + CompositorShadow.clear() + } + + @After fun tearDown() { + shadowOf(Looper.getMainLooper()).idle() + SessionState.outputSize = previousSize + SessionState.mode = previousMode + SessionState.steamUi = previousSteamUi + } + + @Test fun penHoverMovesThePointerAndTheCursorOnTheDesktopAndInSteam() { + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 10, pen to 500f))) + assertEquals(listOf(Pen(PEN_IN, InputSpace.fixedX(500f, 1000), InputSpace.fixedY(300f, 600))), CompositorShadow.pens) + assertTrue(state("cursorVisible").value) + assertEquals(Offset(500f, 300f), state("cursorPos").value) + steamDirect(SessionPrefs.PEN_MOUSE) + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 20, pen to 600f))) + assertEquals(Pen(PEN_IN, InputSpace.fixedX(600f, 1000), InputSpace.fixedY(300f, 600)), CompositorShadow.pens.last()) + assertEquals(Offset(600f, 300f), state("cursorPos").value) + assertTrue(CompositorShadow.pointers.isEmpty()) + assertTrue(CompositorShadow.touches.isEmpty()) + } + + @Test fun theSideButtonSettingDecidesWhatThePrimaryButtonSends() { + val cases = listOf(SessionPrefs.PEN_BUTTON_RIGHT to PEN_RIGHT, SessionPrefs.PEN_BUTTON_MIDDLE to PEN_MIDDLE, + SessionPrefs.PEN_BUTTON_OFF to 0) + for ((step, case) in cases.withIndex()) { + SessionPrefs.setPenSetting(activity, "penButton", case.first) + invoke("readPrefs") + CompositorShadow.pens.clear() + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 10L + 10 * step, pen to 500f, + buttons = MotionEvent.BUTTON_STYLUS_PRIMARY))) + assertEquals(case.first, listOf(PEN_IN or case.second), CompositorShadow.pens.map { it.flags }) + } + } + + @Test fun penContactInMouseModeHoldsTheTipUntilItLifts() { + steamDirect(SessionPrefs.PEN_MOUSE) + assertTrue(activity.onTouchEvent(event(MotionEvent.ACTION_DOWN, 10, pen to 500f))) + assertTrue(activity.onTouchEvent(event(MotionEvent.ACTION_MOVE, 20, pen to 520f))) + assertTrue(activity.onTouchEvent(event(MotionEvent.ACTION_UP, 30, pen to 520f))) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(PenStream.EXIT_GRACE_MS)) + assertEquals(listOf(PEN_IN or PEN_TIP, PEN_IN or PEN_TIP, PEN_IN, 0), CompositorShadow.pens.map { it.flags }) + assertTrue(CompositorShadow.touches.isEmpty()) + } + + @Test fun anExternalTabletTipReachesThePenInsteadOfTheMouse() { + steamDirect(SessionPrefs.PEN_MOUSE) + val source = InputDevice.SOURCE_MOUSE or InputDevice.SOURCE_STYLUS + assertTrue(activity.onTouchEvent(event(MotionEvent.ACTION_DOWN, 10, pen to 500f, source = source))) + assertEquals(listOf(PEN_IN or PEN_TIP), CompositorShadow.pens.map { it.flags }) + assertTrue(CompositorShadow.pointers.isEmpty()) + } + + @Test fun penContactInTouchModeTakesTheFingerRouteAsBefore() { + steamDirect(SessionPrefs.PEN_TOUCH) + assertTrue(activity.onTouchEvent(event(MotionEvent.ACTION_DOWN, 10, pen to 500f))) + assertEquals(listOf(Touch(0, 0, InputSpace.x(500f, 1000), InputSpace.y(300f, 600))), CompositorShadow.touches) + activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 20, pen to 600f)) + assertTrue(CompositorShadow.pens.isEmpty()) + assertTrue(CompositorShadow.pointers.isEmpty()) + } + + @Test fun anExternalTabletStaysOnTheMousePathInTouchMode() { + steamDirect(SessionPrefs.PEN_TOUCH) + val source = InputDevice.SOURCE_MOUSE or InputDevice.SOURCE_STYLUS + assertTrue(activity.onTouchEvent(event(MotionEvent.ACTION_DOWN, 10, pen to 500f, source = source))) + assertTrue(CompositorShadow.touches.isEmpty()) + assertTrue(CompositorShadow.pens.isEmpty()) + } + + @Test fun fingersKeepTheirRouteWhateverThePenMode() { + for (mode in listOf(SessionPrefs.PEN_MOUSE, SessionPrefs.PEN_TOUCH)) { + steamDirect(mode) + CompositorShadow.clear() + assertTrue(activity.onTouchEvent(event(MotionEvent.ACTION_DOWN, 10, finger to 500f, source = InputDevice.SOURCE_TOUCHSCREEN))) + assertEquals(listOf(Touch(0, 0, InputSpace.x(500f, 1000), InputSpace.y(300f, 600))), CompositorShadow.touches) + assertTrue(CompositorShadow.pens.isEmpty()) + activity.onTouchEvent(event(MotionEvent.ACTION_CANCEL, 20, finger to 500f, source = InputDevice.SOURCE_TOUCHSCREEN)) + } + } + + @Test fun aFingerAndAPenInOneEventAreSplitByToolType() { + steamDirect(SessionPrefs.PEN_MOUSE) + activity.onTouchEvent(event(MotionEvent.ACTION_DOWN, 10, finger to 100f)) + activity.onTouchEvent(event(MotionEvent.ACTION_POINTER_DOWN or (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT), 20, finger to 110f, pen to 500f)) + assertEquals(listOf(PEN_IN or PEN_TIP), CompositorShadow.pens.map { it.flags }) + assertEquals(InputSpace.fixedX(500f, 1000), CompositorShadow.pens.last().x) + assertTrue(CompositorShadow.touches.isNotEmpty()) + assertTrue(CompositorShadow.touches.all { it.id == 0 && it.x < InputSpace.x(200f, 1000) }) + } + + @Test fun theLowerScreenGameTakesPenHoverAndContact() { + steamDirect(SessionPrefs.PEN_MOUSE) + fun hover(event: MotionEvent) = ReflectionHelpers.callInstanceMethod(activity, "onBottomGameHover", + ReflectionHelpers.ClassParameter.from(MotionEvent::class.java, event)) + fun touch(event: MotionEvent) = ReflectionHelpers.callInstanceMethod(activity, "onBottomGameTouch", + ReflectionHelpers.ClassParameter.from(MotionEvent::class.java, event)) + assertTrue(hover(event(MotionEvent.ACTION_HOVER_MOVE, 10, pen to 500f))) + assertTrue(touch(event(MotionEvent.ACTION_DOWN, 20, pen to 500f, source = InputDevice.SOURCE_MOUSE or InputDevice.SOURCE_STYLUS))) + assertEquals(listOf(PEN_IN, PEN_IN or PEN_TIP), CompositorShadow.pens.map { it.flags }) + SessionPrefs.setPenSetting(activity, "pen", SessionPrefs.PEN_TOUCH) + invoke("readPrefs") + assertFalse(hover(event(MotionEvent.ACTION_HOVER_MOVE, 30, pen to 500f))) + assertFalse(hover(event(MotionEvent.ACTION_HOVER_MOVE, 40, finger to 500f, source = InputDevice.SOURCE_MOUSE))) + assertEquals(listOf(PEN_IN, PEN_IN or PEN_TIP, 0), CompositorShadow.pens.map { it.flags }) + } + + @Test fun glassesAProgramPointerLockAndAppUiDropPenHover() { + state("glassesOutputActive").value = true + activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 10, pen to 500f)) + state("glassesOutputActive").value = false + SessionState.mode = SessionService.MODE_STEAM + field("pointerLocked", true) + activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 20, pen to 500f)) + field("pointerLocked", false) + state("achievementsOpen").value = true + activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 30, pen to 500f)) + assertTrue(CompositorShadow.pens.isEmpty()) + assertTrue(CompositorShadow.pointers.isEmpty()) + } + + @Config(sdk = [34]) + @Test fun aPenNearTheDesktopReleasesTheMouseGrabUntilItLeaves() { + shadowOf(activity.getSystemService(InputManager::class.java)).addInputDevice( + InputDeviceBuilder.newBuilder().setId(11).setName("mouse").setSources(InputDevice.SOURCE_MOUSE).build()) + field("desktopMousePlaced", true) + field("pointerLocked", true) + val start = android.os.SystemClock.uptimeMillis() + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, start, pen to 500f))) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(1)) + assertEquals(listOf(RIGHT_CTRL to 1, RIGHT_CTRL to 0), CompositorShadow.keys) + field("pointerLocked", false) + invoke("grabDesktopMouse") + assertEquals(2, CompositorShadow.keys.size) + activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_EXIT, start + 1_000, pen to 500f)) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(PenStream.EXIT_GRACE_MS)) + invoke("grabDesktopMouse") + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(1)) + assertEquals(listOf(RIGHT_CTRL to 1, RIGHT_CTRL to 0, RIGHT_CTRL to 1, RIGHT_CTRL to 0), CompositorShadow.keys) + } + + @Test fun openingAppUiEndsAHoveringPen() { + activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 10, pen to 500f)) + state("achievementsOpen").value = true + activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 20, pen to 510f)) + assertEquals(listOf(PEN_IN, 0), CompositorShadow.pens.map { it.flags }) + } + + @Test fun touchModeAndRouteChangesDeviceRemovalAndPauseEndThePen() { + invoke("readPrefs") + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 10, pen to 500f))) + SessionPrefs.setTouchMode(activity, SessionPrefs.TOUCH_DIRECT) + invoke("readPrefs") + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 20, pen to 500f))) + field("routedTouchMode", SessionPrefs.TOUCH_PAD) + invoke("applyTouchRouting") + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 30, pen to 500f))) + ReflectionHelpers.getField(activity, "deviceListener").onInputDeviceRemoved(6) + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 40, pen to 500f))) + invoke("onPause") + assertEquals(listOf(PEN_IN, 0, PEN_IN, 0, PEN_IN, 0, PEN_IN, 0), CompositorShadow.pens.map { it.flags }) + } + + @Config(sdk = [34], shadows = [PadBridgeRoutingTest.RegisteredKeyEvent::class]) + @Test fun aHeldPenKeyOutlivesATouchCancelButNotAFocusLoss() { + penKeyboard() + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 10, pen to 500f))) + assertTrue(penKey(KeyEvent.ACTION_DOWN, 15)) + invoke("cancelTouchGestures") + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 20, pen to 500f))) + invoke("releaseHeldGuestInput") + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 30, pen to 500f))) + val right = PEN_IN or PEN_RIGHT + assertEquals(listOf(PEN_IN, right, 0, right, 0, PEN_IN), CompositorShadow.pens.map { it.flags }) + } + + @Config(sdk = [34], shadows = [PadBridgeRoutingTest.RegisteredKeyEvent::class]) + @Test fun aPenKeyIsAnOrdinaryKeyInTouchMode() { + penKeyboard() + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 10, pen to 500f))) + assertTrue(penKey(KeyEvent.ACTION_DOWN, 15)) + SessionPrefs.setPenSetting(activity, "pen", SessionPrefs.PEN_TOUCH) + invoke("readPrefs") + assertTrue(penKey(KeyEvent.ACTION_UP, 20)) + assertFalse(penKey(KeyEvent.ACTION_DOWN, 25)) + assertFalse(penKey(KeyEvent.ACTION_UP, 30)) + assertEquals(listOf(PEN_IN, PEN_IN or PEN_RIGHT, 0), CompositorShadow.pens.map { it.flags }) + } + + @Test fun aFingerAndARelativePenOnTheTouchpadStayOneTwoPointerStream() { + state("glassesOutputActive").value = true + field("padMouseCheckedAt", android.os.SystemClock.uptimeMillis()) + for (penFirst in listOf(false, true)) { + val pad = touchpad() + val first = if (penFirst) pen to 500f else finger to 100f + val second = if (penFirst) finger to 100f else pen to 500f + fun both(step: Int) = arrayOf(first.first to first.second + 10f * step, second.first to second.second + 10f * step) + activity.onTouchEvent(event(MotionEvent.ACTION_DOWN, 10_000, first)) + activity.onTouchEvent(event(MotionEvent.ACTION_POINTER_DOWN or (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT), 10_010, *both(0))) + for (step in 1..4) activity.onTouchEvent(event(MotionEvent.ACTION_MOVE, 10_010L + 10 * step, *both(step))) + activity.onTouchEvent(event(MotionEvent.ACTION_POINTER_UP or (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT), 10_060, *both(4))) + activity.onTouchEvent(event(MotionEvent.ACTION_UP, 10_070, first.first to first.second + 40f)) + assertTrue("penFirst=$penFirst", pad.scrolls.isNotEmpty()) + assertTrue("penFirst=$penFirst ${pad.moves}", pad.moves.all { it in 450f..550f }) + assertTrue(CompositorShadow.pens.isEmpty()) + } + } + + @Test fun aRelativePenStrokeThatAndroidCanceledDoesNotClick() { + steamDirect(SessionPrefs.PEN_MOUSE) + state("glassesOutputActive").value = true + val pad = touchpad() + activity.onTouchEvent(event(MotionEvent.ACTION_DOWN, 10_000, finger to 100f)) + activity.onTouchEvent(event(MotionEvent.ACTION_POINTER_DOWN or (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT), 10_010, finger to 100f, pen to 500f)) + activity.onTouchEvent(event(MotionEvent.ACTION_POINTER_UP or (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT), 10_050, finger to 100f, pen to 500f, + flags = MotionEvent.FLAG_CANCELED)) + activity.onTouchEvent(event(MotionEvent.ACTION_UP, 10_060, finger to 100f)) + activity.onTouchEvent(event(MotionEvent.ACTION_DOWN, 20_000, pen to 500f)) + activity.onTouchEvent(event(MotionEvent.ACTION_UP, 20_050, pen to 500f, flags = MotionEvent.FLAG_CANCELED)) + assertTrue(pad.presses.isEmpty()) + assertTrue(CompositorShadow.touches.isNotEmpty()) + activity.onTouchEvent(event(MotionEvent.ACTION_DOWN, 30_000, pen to 500f)) + activity.onTouchEvent(event(MotionEvent.ACTION_UP, 30_050, pen to 500f)) + assertEquals(listOf(PointerGestures.BTN_LEFT), pad.presses) + assertTrue(CompositorShadow.pens.isEmpty()) + } + + @Test fun aTouchCancelAfterAFingerLiftsEndsTheRelativePenStroke() { + steamDirect(SessionPrefs.PEN_MOUSE) + state("glassesOutputActive").value = true + val pad = touchpad() + activity.onTouchEvent(event(MotionEvent.ACTION_DOWN, 10_000, pen to 500f)) + activity.onTouchEvent(event(MotionEvent.ACTION_POINTER_DOWN or (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT), 10_010, pen to 500f, finger to 100f)) + activity.onTouchEvent(event(MotionEvent.ACTION_POINTER_UP or (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT), 10_020, pen to 500f, finger to 100f)) + invoke("cancelTouchGestures") + activity.onTouchEvent(event(MotionEvent.ACTION_UP, 10_050, pen to 500f)) + assertTrue(pad.presses.isEmpty()) + activity.onTouchEvent(event(MotionEvent.ACTION_DOWN, 20_000, pen to 500f)) + activity.onTouchEvent(event(MotionEvent.ACTION_UP, 20_050, pen to 500f)) + assertEquals(listOf(PointerGestures.BTN_LEFT), pad.presses) + } + + @Test fun changingAPenSettingEndsThePenAndRereadingTheSameSettingsDoesNot() { + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 10, pen to 500f))) + invoke("readPrefs") + assertEquals(listOf(PEN_IN), CompositorShadow.pens.map { it.flags }) + for ((step, setting) in listOf("penButton" to SessionPrefs.PEN_BUTTON_MIDDLE, "pen" to SessionPrefs.PEN_TOUCH).withIndex()) { + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 20L + 10 * step, pen to 500f))) + SessionPrefs.setPenSetting(activity, setting.first, setting.second) + invoke("readPrefs") + assertEquals(setting.first, 0, CompositorShadow.pens.last().flags) + } + } + + @Test fun theFirstPenEventRemembersThatThePhoneHasAPen() { + invoke("readPrefs") + assertFalse(state("penSeen").value) + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 10, pen to 500f))) + assertTrue(state("penSeen").value) + assertTrue(SessionPrefs.penSeen(activity)) + } + + @Config(sdk = [34]) + @Test fun aConnectedStylusDeviceCountsAsSeenBeforeAnyPenEvent() { + invoke("readPrefs") + assertFalse(state("penSeen").value) + shadowOf(activity.getSystemService(InputManager::class.java)).addInputDevice( + InputDeviceBuilder.newBuilder().setId(42).setName("digitizer").setSources(stylusScreen).build()) + invoke("readPrefs") + assertTrue(state("penSeen").value) + assertTrue(SessionPrefs.penSeen(activity)) + } + + @Config(sdk = [33]) + @Test fun beforeAndroid14ATouchscreenWithTheStylusBitWaitsForAPenEvent() { + shadowOf(activity.getSystemService(InputManager::class.java)).addInputDevice( + ShadowInputDevice.makeInputDeviceNamed("touchscreen").also { + ReflectionHelpers.setField(it, "mId", 42) + ReflectionHelpers.setField(it, "mSources", stylusScreen) + }) + assertEquals(listOf(42), InputDevice.getDeviceIds().toList()) + invoke("readPrefs") + assertFalse(state("penSeen").value) + assertFalse(SessionPrefs.penSeen(activity)) + assertTrue(activity.dispatchGenericMotionEvent(event(MotionEvent.ACTION_HOVER_MOVE, 10, pen to 500f))) + assertTrue(state("penSeen").value) + } + + @Config(sdk = [34]) + @Test fun aStylusDeviceIsNotAHardwareMouse() { + fun device(sources: Int) = InputDeviceBuilder.newBuilder().setId(7).setName("device").setSources(sources).build() + fun mouse(sources: Int) = ReflectionHelpers.callInstanceMethod(activity, "isHardwareMouse", + ReflectionHelpers.ClassParameter.from(InputDevice::class.java, device(sources))) + assertTrue(mouse(InputDevice.SOURCE_MOUSE)) + assertFalse(mouse(InputDevice.SOURCE_MOUSE or InputDevice.SOURCE_STYLUS)) + assertFalse(mouse(InputDevice.SOURCE_MOUSE or InputDevice.SOURCE_STYLUS or InputDevice.SOURCE_KEYBOARD)) + assertFalse(mouse(stylusScreen)) + } + + private fun steamDirect(mode: String) { + SessionPrefs.setPenSetting(activity, "pen", mode) + invoke("readPrefs") + SessionState.mode = SessionService.MODE_STEAM + field("routedTouchMode", SessionPrefs.TOUCH_DIRECT) + field("padMouseCheckedAt", android.os.SystemClock.uptimeMillis()) + field("threeFingerTap", ThreeFingerTap(8f)) + field("directTouchHold", DirectTouchHold(8f, object : PointerGestures.Listener { + override fun onMove(x: Float, y: Float) {} + override fun onButton(button: Int, pressed: Boolean, x: Float, y: Float) {} + override fun onWheel(steps: Int) {} + override fun onLongPress() {} + }, ReflectionHelpers.getField(activity, "directTouchSink")).also { + it.configure(TouchGestureConfig(directHoldBehavior = TouchGestureConfig.MOUSE_BEHAVIOR_NONE)) + }) + } + + private fun penKeyboard() = shadowOf(activity.getSystemService(InputManager::class.java)).addInputDevice( + InputDeviceBuilder.newBuilder().setId(10).setName("OPPO AI Pen").setSources(InputDevice.SOURCE_KEYBOARD).setExternal(true) + .setKeyboardType(InputDevice.KEYBOARD_TYPE_NON_ALPHABETIC).build()) + + private fun penKey(action: Int, time: Long) = + activity.dispatchKeyEvent(KeyEvent(time, time, action, KeyEvent.KEYCODE_UNKNOWN, 0, 0, 10, 191, 0, InputDevice.SOURCE_KEYBOARD)) + + private fun event(action: Int, time: Long, vararg pointers: Pair, source: Int = stylusScreen, flags: Int = 0, + buttons: Int = 0): MotionEvent { + val properties = Array(pointers.size) { MotionEvent.PointerProperties().apply { id = it; toolType = pointers[it].first } } + val coords = Array(pointers.size) { MotionEvent.PointerCoords().apply { x = pointers[it].second; y = 300f; pressure = 0.5f } } + return MotionEvent.obtain(0, time, action, pointers.size, properties, coords, 0, buttons, 1f, 1f, 6, 0, source, flags) + } + + private class Pad : PointerGestures.Listener { + val moves = mutableListOf() + val scrolls = mutableListOf() + val presses = mutableListOf() + override fun onMove(x: Float, y: Float) { moves += x } + override fun onButton(button: Int, pressed: Boolean, x: Float, y: Float) { if (pressed) presses += button } + override fun onWheel(steps: Int) {} + override fun onLongPress() {} + override fun onScroll(dx: Float, dy: Float) { scrolls += dx } + } + + private fun touchpad() = Pad().also { field("touchpad", TouchpadGestures(8f, it)) } + + private fun field(name: String, value: Any) = ReflectionHelpers.setField(activity, name, value) + private fun invoke(name: String) = ReflectionHelpers.callInstanceMethod(activity, name) + private fun state(name: String): MutableState = ReflectionHelpers.getField(activity, "$name\$delegate") + + private companion object { const val RIGHT_CTRL = 97 } + + data class Pen(val flags: Int, val x: Int, val y: Int) + data class Touch(val action: Int, val id: Int, val x: Int, val y: Int) + + @Implements(value = WaylandCompositor::class, isInAndroidSdk = false) + class CompositorShadow { + companion object { + val pens = mutableListOf() + val touches = mutableListOf() + val pointers = mutableListOf>() + val keys = mutableListOf>() + fun clear() { pens.clear(); touches.clear(); pointers.clear(); keys.clear() } + @JvmStatic @Implementation fun __staticInitializer__() {} + @JvmStatic @Implementation fun nativeSendPen(flags: Int, x: Int, y: Int) { pens += Pen(flags, x, y) } + @JvmStatic @Implementation fun nativeSendTouch(action: Int, id: Int, x: Int, y: Int) { touches += Touch(action, id, x, y) } + @JvmStatic @Implementation fun nativeSendPointer(action: Int, x: Int, y: Int) { pointers += Triple(action, x, y) } + @JvmStatic @Implementation fun nativeSendSceneInput(type: Int, code: Int, value: Int) {} + @JvmStatic @Implementation fun nativeSendKey(code: Int, value: Int) { keys += code to value } + @JvmStatic @Implementation fun nativeFocusTakesTouch(): Boolean = false + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/input/ShortcutsRelayTest.kt b/app/src/test/java/com/droiddeck/launcher/input/ShortcutsRelayTest.kt new file mode 100644 index 0000000000..2a8d99cd81 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/input/ShortcutsRelayTest.kt @@ -0,0 +1,98 @@ +package com.droiddeck.launcher.input + +import android.app.Application +import android.content.Intent +import android.content.pm.ApplicationInfo +import android.content.pm.PackageInfo +import android.graphics.Rect +import android.os.IBinder +import android.os.Parcel +import android.provider.Settings +import androidx.test.core.app.ApplicationProvider +import com.droiddeck.launcher.core.SteamIntegration +import com.droiddeck.shortcuts.Relay +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config +import org.robolectric.shadows.ShadowBinder + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [33], application = Application::class) +class ShortcutsRelayTest { + private val context: Application = ApplicationProvider.getApplicationContext() + private val companionUid = 10_999 + + private fun choose(value: String?) = + Settings.Secure.putString(context.contentResolver, Settings.Secure.ENABLED_ACCESSIBILITY_SERVICES, value) + + private fun installCompanion() { + val app = ApplicationInfo().apply { packageName = Relay.PACKAGE; uid = companionUid } + shadowOf(context.packageManager).installPackage(PackageInfo().apply { packageName = Relay.PACKAGE; applicationInfo = app }) + shadowOf(context.packageManager).setPackagesForUid(companionUid, Relay.PACKAGE) + } + + private fun config(binder: IBinder, uid: Int): Int? { + val data = Parcel.obtain() + val reply = Parcel.obtain() + try { + data.writeInterfaceToken(Relay.DESCRIPTOR) + ShadowBinder.setCallingUid(uid) + if (!binder.transact(Relay.CONFIG, data, reply, 0)) return null + reply.setDataPosition(0) + return reply.readInt() + } finally { + ShadowBinder.reset() + data.recycle() + reply.recycle() + } + } + + @Test fun droidDeckDeclaresNoAccessibilityService() { + val services = context.packageManager.queryIntentServices( + Intent("android.accessibilityservice.AccessibilityService").setPackage(context.packageName), 0) + assertTrue(services.isEmpty()) + } + + @Test fun theCompanionFindsTheRelay() { + val relays = context.packageManager.queryIntentServices(Intent(Relay.ACTION).setPackage(context.packageName), 0) + assertEquals(listOf(ShortcutsRelay::class.java.name), relays.map { it.serviceInfo.name }) + } + + @Test fun shortcutsAreOnOnlyWhileTheCompanionServiceIsEnabled() { + assertFalse(SteamIntegration.shortcutsEnabled(context)) + choose("other.app/.Reader:${Relay.PACKAGE}/${Relay.SERVICE}") + assertTrue(SteamIntegration.shortcutsEnabled(context)) + choose("${Relay.PACKAGE}/.ShortcutsService") + assertTrue(SteamIntegration.shortcutsEnabled(context)) + choose("other.app/.Reader") + assertFalse(SteamIntegration.shortcutsEnabled(context)) + } + + @Test fun theRelayAnswersOnlyTheEnabledCompanion() { + installCompanion() + val binder = Robolectric.buildService(ShortcutsRelay::class.java).create().get().onBind(Intent(Relay.ACTION)) + assertNull(config(binder, companionUid)) + choose("${Relay.PACKAGE}/${Relay.SERVICE}") + assertNull(config(binder, 10_998)) + assertEquals(0, config(binder, companionUid)) + } + + @Test fun windowSnapshotsSurviveTheTrip() { + val sent = mapOf(2 to listOf(Relay.Window(7, 1, 3, Rect(0, 0, 1080, 1240), "guest.app"), Relay.Window(8, 2, 1, Rect(1, 2, 3, 4), null))) + val got = Relay.decode(Relay.encode(sent)) + assertEquals(setOf(2), got.keys) + val windows = got.getValue(2) + assertEquals(listOf(7, 8), windows.map { it.id }) + assertEquals(listOf(1, 2), windows.map { it.type }) + assertEquals(listOf(3, 1), windows.map { it.layer }) + assertEquals(listOf(Rect(0, 0, 1080, 1240), Rect(1, 2, 3, 4)), windows.map { it.bounds }) + assertEquals(listOf("guest.app", null), windows.map { it.pkg }) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/session/GameThreadHintsTest.kt b/app/src/test/java/com/droiddeck/launcher/session/GameThreadHintsTest.kt index 8233957e2a..ff5867d4c2 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/GameThreadHintsTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/GameThreadHintsTest.kt @@ -6,6 +6,15 @@ import org.junit.Assert.assertTrue import org.junit.Test class GameThreadHintsTest { + @Test fun `hints run on the Snapdragon 8 Elite only`() { + assertTrue(GameThreadHints.supported("CQ8725S")) + assertTrue(GameThreadHints.supported("SM8750")) + assertTrue(GameThreadHints.supported("QTI SM8750")) + assertFalse(GameThreadHints.supported("SM8650")) + assertFalse(GameThreadHints.supported("SM8850")) + assertFalse(GameThreadHints.supported("")) + } + @Test fun `a thread joins above 60 percent and leaves under 15`() { assertEquals(emptySet(), GameThreadHints.pick(emptySet(), mapOf(1 to 0.55))) assertEquals(setOf(1), GameThreadHints.pick(emptySet(), mapOf(1 to 0.68))) diff --git a/app/src/test/java/com/droiddeck/launcher/session/RumbleComponentTest.kt b/app/src/test/java/com/droiddeck/launcher/session/RumbleComponentTest.kt index 78741888d3..c1f71bef54 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/RumbleComponentTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/RumbleComponentTest.kt @@ -36,7 +36,12 @@ class RumbleComponentTest { vibrator = if (Build.VERSION.SDK_INT >= 31) context.getSystemService(VibratorManager::class.java).defaultVibrator else context.getSystemService(Vibrator::class.java) shadowOf(vibrator).setHasVibrator(true) - rumble = RumbleComponent().also { it.motorLooper = Looper.getMainLooper(); it.attach(context); it.start() } + rumble = RumbleComponent().also { + it.motorLooper = Looper.getMainLooper() + it.gameRunning = { false } + it.attach(context) + it.start() + } } @After fun stopListener() { rumble.stop() } @@ -115,6 +120,143 @@ class RumbleComponentTest { assertFalse(pad.vibrating) } + @Test fun aHeldEffectStopsWhenTheProcessThatStartedItIsGone() { + val pad = FakeMotors() + var alive = true + rumble.controllerMotors = { pad } + rumble.processStart = { pid -> if (pid == SENDER && alive) "1234" else null } + rumble.gameRunning = { false } + activeController(PAD_ID) + effectFrom(SENDER, ms = RumbleComponent.HOLD_MS) + idle(RumbleComponent.KEEPALIVE_MS * 2 + 100) + assertTrue(pad.vibrating) + alive = false + idle(RumbleComponent.KEEPALIVE_MS * 2 + 100) + assertFalse("a crashed game's rumble kept going", pad.vibrating) + val played = pad.played.size + idle(RumbleComponent.KEEPALIVE_MS * 4) + assertEquals("the keepalive restarted the motors", played, pad.played.size) + } + + @Test fun aHeldEffectStopsWhenTheGameItStartedInExits() { + val pad = FakeMotors() + var game = true + rumble.controllerMotors = { pad } + rumble.processStart = { "1234" } + rumble.gameRunning = { game } + activeController(PAD_ID) + effectFrom(SENDER, ms = RumbleComponent.HOLD_MS) + idle(RumbleComponent.KEEPALIVE_MS * 2 + 100) + assertTrue(pad.vibrating) + game = false + idle(RumbleComponent.KEEPALIVE_MS + 100) + assertFalse("rumble outlived the game", pad.vibrating) + game = true + effectFrom(SENDER, ms = RumbleComponent.HOLD_MS) + assertTrue("the next game's rumble was dropped", pad.vibrating) + } + + @Test fun aProcessStartTimeIsReadForALiveProcessOnly() { + val self = java.io.File("/proc/self").canonicalFile.name.toInt() + val start = RumbleComponent.readProcessStart(self) + assertNotNull(start) + assertNotEquals(RumbleComponent.UNKNOWN_START, start) + assertEquals("the start time changed for the same process", start, RumbleComponent.readProcessStart(self)) + assertNull(RumbleComponent.readProcessStart(Int.MAX_VALUE)) + } + + @Test fun aGameThatExitsBeforeTheFirstKeepaliveStillStopsItsRumble() { + val pad = FakeMotors() + var game = true + rumble.controllerMotors = { pad } + rumble.processStart = { "1234" } + rumble.gameRunning = { game } + activeController(PAD_ID) + effectFrom(SENDER, ms = RumbleComponent.HOLD_MS) + game = false + idle(RumbleComponent.KEEPALIVE_MS + 100) + assertFalse("rumble outlived a game that exited right away", pad.vibrating) + } + + @Test fun aGameStartingRightAfterAnotherHoldIsStillWatched() { + val pad = FakeMotors() + var game = false + rumble.controllerMotors = { pad } + rumble.processStart = { "1234" } + rumble.gameRunning = { game } + activeController(PAD_ID) + effectFrom(SENDER, ms = RumbleComponent.HOLD_MS) + effectFrom(SENDER, strong = 0, weak = 0) + game = true + idle(RumbleComponent.MIN_GAP_MS) + effectFrom(SENDER, ms = RumbleComponent.HOLD_MS) + assertTrue(pad.vibrating) + game = false + idle(RumbleComponent.KEEPALIVE_MS + 100) + assertFalse("a stale no-game result left the hold unwatched", pad.vibrating) + } + + @Test fun anotherProcessClosingItsOlderRumbleLeavesTheNewerOneOnTheSlot() { + val pad = FakeMotors() + rumble.controllerMotors = { pad } + rumble.processStart = { "1234" } + activeController(PAD_ID) + effectFrom(SENDER, ms = RumbleComponent.HOLD_MS) + idle(RumbleComponent.MIN_GAP_MS) + effectFrom(OTHER_SENDER, strong = 30000, ms = RumbleComponent.HOLD_MS) + effectFrom(SENDER, strong = 0, weak = 0) + assertTrue("an older process's stop cancelled newer rumble", pad.vibrating) + effectFrom(OTHER_SENDER, strong = 0, weak = 0) + assertFalse(pad.vibrating) + } + + @Test fun aSenderOfOurOwnUserThatExitedBeforeItsFirstLookupStopsItsRumble() { + val pad = FakeMotors() + rumble.controllerMotors = { pad } + rumble.processStart = { null } + activeController(PAD_ID) + effectFrom(SENDER, ms = RumbleComponent.HOLD_MS, ownUser = true) + assertTrue(pad.vibrating) + idle(RumbleComponent.KEEPALIVE_MS + 100) + assertFalse("rumble outlived a sender that was already gone", pad.vibrating) + } + + @Test fun anUnseenSenderOfAnotherUserKeepsItsRumble() { + val pad = FakeMotors() + rumble.controllerMotors = { pad } + rumble.processStart = { null } + activeController(PAD_ID) + effectFrom(SENDER, ms = RumbleComponent.HOLD_MS, ownUser = false) + idle(RumbleComponent.KEEPALIVE_MS * 3 + 100) + assertTrue("a sender the app can't see lost its rumble", pad.vibrating) + } + + @Test fun aSenderFirstReadAsUnknownStillStopsItsRumbleWhenItExits() { + val pad = FakeMotors() + var start: String? = RumbleComponent.UNKNOWN_START + rumble.controllerMotors = { pad } + rumble.processStart = { start } + activeController(PAD_ID) + effectFrom(SENDER, ms = RumbleComponent.HOLD_MS) + idle(RumbleComponent.KEEPALIVE_MS * 2 + 100) + assertTrue(pad.vibrating) + start = null + idle(RumbleComponent.KEEPALIVE_MS + 100) + assertFalse("rumble outlived its sender", pad.vibrating) + } + + @Test fun anUnreadableButLiveProcessKeepsItsRumble() { + val pad = FakeMotors() + var start: String? = "1234" + rumble.controllerMotors = { pad } + rumble.processStart = { start } + activeController(PAD_ID) + effectFrom(SENDER, ms = RumbleComponent.HOLD_MS) + start = RumbleComponent.UNKNOWN_START + idle(RumbleComponent.KEEPALIVE_MS * 3 + 100) + assertTrue("a passing /proc read error cut the rumble", pad.vibrating) + } + @Test fun quietingStopsAHeldEffectAndDropsEffectsUntilLifted() { val pad = FakeMotors() rumble.controllerMotors = { pad } @@ -280,6 +422,12 @@ class RumbleComponentTest { .apply { isAccessible = true }.invoke(rumble, strong, weak, ms, slot) } + private fun effectFrom(sender: Int, strong: Int = 40000, weak: Int = 20000, slot: Int = 0, ms: Int = 5000, ownUser: Boolean = false) { + val int = Int::class.javaPrimitiveType + RumbleComponent::class.java.getDeclaredMethod("buzz", int, int, int, int, int, Boolean::class.javaPrimitiveType) + .apply { isAccessible = true }.invoke(rumble, strong, weak, ms, slot, sender, ownUser) + } + private fun idle(ms: Long) = shadowOf(Looper.getMainLooper()).idleFor(java.time.Duration.ofMillis(ms)) private class FakeMotors : RumbleComponent.Motors { @@ -293,6 +441,8 @@ class RumbleComponentTest { private companion object { const val PAD_ID = 7 const val SECOND_PAD_ID = 8 + const val SENDER = 4242 + const val OTHER_SENDER = 4343 } @Implements(LocalServerSocket::class) diff --git a/app/src/test/java/com/droiddeck/launcher/session/SessionStartTimeTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SessionStartTimeTest.kt new file mode 100644 index 0000000000..a921752f08 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/session/SessionStartTimeTest.kt @@ -0,0 +1,56 @@ +package com.droiddeck.launcher.session + +import android.content.Context +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import java.io.File + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE) +class SessionStartTimeTest { + private lateinit var context: Context + + @Before fun setUp() { + context = RuntimeEnvironment.getApplication() + SessionPaths.take()?.let { SessionPaths.release(context, it) } + context.getSharedPreferences("session", Context.MODE_PRIVATE).edit().putBoolean("logs", false).commit() + } + + @After fun tearDown() { + SessionPaths.take()?.let { SessionPaths.release(context, it) } + context.getSharedPreferences("session", Context.MODE_PRIVATE).edit().remove("logs").commit() + } + + @Test fun theCurrentFolderKeepsTheTimeItWasMade() { + val before = System.currentTimeMillis() + val folder = SessionPaths.beginOrCurrent(context, "start-time") + val after = System.currentTimeMillis() + val started = SessionPaths.startedAt(folder) + assertTrue(started in before..after) + Thread.sleep(5) + assertEquals(folder, SessionPaths.beginOrCurrent(context, "start-time")) + assertEquals(started, SessionPaths.startedAt(folder)) + } + + @Test fun otherAndEndedFoldersHaveNoStartTime() { + val folder = SessionPaths.beginOrCurrent(context, "start-time") + assertEquals(0L, SessionPaths.startedAt(File(folder.parentFile, "elsewhere"))) + SessionPaths.take()?.let { SessionPaths.release(context, it) } + assertEquals(0L, SessionPaths.startedAt(folder)) + } + + @Test fun theDriverLoaderLinesReachTheGraphicsReport() { + val loader = "11-09 06:09:04.930 20010 24772 I hook_impl: hook_android_dlopen_ext: hook failed: failed to load custom driver: dlopen failed!" + assertTrue(GraphicsReport.COMPOSITOR.containsMatchIn(loader)) + assertTrue(GraphicsReport.COMPOSITOR.containsMatchIn("11-09 06:09:04.931 20010 24772 E adrenotools: Couldn't preload the hook implementation")) + assertFalse(GraphicsReport.COMPOSITOR.containsMatchIn("11-09 06:09:05.563 20010 24802 I SessionService: game thread hints: Odin 3 only")) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/session/SessionTerminalKeepTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SessionTerminalKeepTest.kt new file mode 100644 index 0000000000..24695e9bcf --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/session/SessionTerminalKeepTest.kt @@ -0,0 +1,74 @@ +package com.droiddeck.launcher.session + +import com.termux.terminal.TerminalSession +import com.termux.terminal.TerminalSessionClient +import org.junit.After +import org.junit.Assert.assertNull +import org.junit.Assert.assertSame +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config +import java.io.File +import java.lang.reflect.Proxy + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE) +class SessionTerminalKeepTest { + private val client = Proxy.newProxyInstance( + TerminalSessionClient::class.java.classLoader, arrayOf(TerminalSessionClient::class.java), + ) { _, method, _ -> if (method.returnType == Int::class.javaPrimitiveType) 0 else null } as TerminalSessionClient + + private fun prepare(generation: Int) = + SessionTerminal.prepare(listOf("/bin/sh"), emptyArray(), File("/"), generation) + + private fun unstarted() = TerminalSession("/bin/sh", "/", arrayOf("/bin/sh"), emptyArray(), 3000, client) + + @After fun reset() = SessionTerminal.clear() + + @Test fun aKeptShellIsReusedByTheNextPanel() { + prepare(1) + val shell = unstarted() + SessionTerminal.keep(shell) + assertSame(shell, SessionTerminal.reuse(client)) + } + + @Test fun aReleasedShellIsNotReused() { + prepare(1) + val shell = unstarted() + SessionTerminal.keep(shell) + SessionTerminal.release(shell) + assertNull(SessionTerminal.reuse(client)) + } + + @Test fun aShellFromAnEarlierSessionIsNotReused() { + prepare(1) + SessionTerminal.keep(unstarted()) + prepare(2) + assertNull(SessionTerminal.reuse(client)) + } + + @Test fun detachingDropsTheShellWithoutAPidForAShellThatNeverStarted() { + prepare(1) + SessionTerminal.keep(unstarted()) + assertNull(SessionTerminal.detach(1)) + prepare(1) + assertNull(SessionTerminal.reuse(client)) + } + + @Test fun detachingAnotherGenerationKeepsTheShell() { + prepare(2) + val shell = unstarted() + SessionTerminal.keep(shell) + assertNull(SessionTerminal.detach(1)) + assertSame(shell, SessionTerminal.reuse(client)) + } + + @Test fun clearingTheSessionDropsTheKeptShell() { + prepare(1) + SessionTerminal.keep(unstarted()) + SessionTerminal.clear(1) + prepare(1) + assertNull(SessionTerminal.reuse(client)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/session/SettingsResetTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SettingsResetTest.kt index 4220961071..bc49532c66 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/SettingsResetTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/SettingsResetTest.kt @@ -34,6 +34,9 @@ class SettingsResetTest { @Test fun settingsGoBackToTheirDefaults() { SessionPrefs.setTheme(app, "ocean") SessionPrefs.setBackDoubleTapMs(app, 100) + SessionPrefs.setPenSetting(app, "pen", SessionPrefs.PEN_TOUCH) + SessionPrefs.setPenSetting(app, "penButton", SessionPrefs.PEN_BUTTON_OFF) + SessionPrefs.setPenSeen(app) SessionPrefs.setUnfoldedControlsWithController(app, true) SessionPrefs.setNoXalia(app, false) session.edit().putInt("fpsLimit.steam", 30).commit() @@ -58,6 +61,8 @@ class SettingsResetTest { assertEquals("graphite", SessionPrefs.theme(app)) assertEquals(500, SessionPrefs.backDoubleTapMs(app)) + assertEquals(SessionPrefs.Pen(), SessionPrefs.pen(app)) + assertTrue(SessionPrefs.penSeen(app)) assertFalse(SessionPrefs.unfoldedControlsWithController(app)) assertTrue(SessionPrefs.noXalia(app)) assertFalse(session.contains("fpsLimit.steam")) @@ -82,6 +87,26 @@ class SettingsResetTest { assertFalse(prefs("steam_touch").contains("gyro")) } + @Test fun penSettingsKeepOnlyKnownValues() { + val settings = mapOf( + "pen" to listOf(SessionPrefs.PEN_MOUSE, SessionPrefs.PEN_TOUCH), + "penButton" to listOf(SessionPrefs.PEN_BUTTON_RIGHT, SessionPrefs.PEN_BUTTON_MIDDLE, SessionPrefs.PEN_BUTTON_OFF), + ) + fun read(key: String) = if (key == "pen") SessionPrefs.penMode(app) else SessionPrefs.penButton(app) + for ((key, values) in settings) { + assertTrue(key, SettingsReset.isSessionSetting(key)) + assertEquals(key, values.first(), read(key)) + for (value in values.drop(1)) { + SessionPrefs.setPenSetting(app, key, value) + assertEquals(key, value, read(key)) + } + session.edit().putString(key, "left").commit() + assertEquals(key, values.first(), read(key)) + assertThrows(IllegalArgumentException::class.java) { SessionPrefs.setPenSetting(app, key, "left") } + } + assertFalse(SettingsReset.isSessionSetting("penSeen")) + } + @Test fun aFailedDebugOptOutDoesNotHideTheEnabledPreference() { assertTrue(SessionPrefs.setGameDebugLogsEnabled(app, true)) val directory = java.io.File(com.droiddeck.launcher.runtime.LinuxRuntime.rootDir(app), diff --git a/app/src/test/java/com/droiddeck/launcher/session/SteamGameProcessTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SteamGameProcessTest.kt index 7a1723b95f..fc1a1bb276 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/SteamGameProcessTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/SteamGameProcessTest.kt @@ -13,17 +13,46 @@ class SteamGameProcessTest { private fun cmdline(vararg args: String) = args.joinToString("\u0000", postfix = "\u0000").toByteArray() @Test fun theSessionsOwnSearchesAreNotAGame() { - assertFalse(SteamGameProcess.matches(cmdline("pgrep", "-a", "-f", "SteamLaunch AppId=[0-9]"))) - assertFalse(SteamGameProcess.matches(cmdline("pgrep", "-f", "reaper SteamLaunch"))) - assertFalse(SteamGameProcess.matches(cmdline("pgrep", "-f", "reaper SteamLaunch AppId=976310( |$)"))) - assertFalse(SteamGameProcess.matches(cmdline("sh", "-c", "pgrep -f 'proton waitforexitandrun'"))) - assertFalse(SteamGameProcess.matches(cmdline("/usr/bin/steam", "steam://rungameid/976310"))) + assertFalse(SteamGameProcess.matches(cmdline("pgrep", "-a", "-f", "SteamLaunch AppId=[0-9]"), "976310")) + assertFalse(SteamGameProcess.matches(cmdline("pgrep", "-f", "reaper SteamLaunch"), "976310")) + assertFalse(SteamGameProcess.matches(cmdline("pgrep", "-f", "reaper SteamLaunch AppId=976310( |$)"), "976310")) + assertFalse(SteamGameProcess.matches(cmdline("sh", "-c", "pgrep -f 'proton waitforexitandrun'"), "976310")) + assertFalse(SteamGameProcess.matches(cmdline("/usr/bin/steam", "steam://rungameid/976310"), "976310")) + assertFalse(SteamGameProcess.matches(cmdline("reaper", "SteamLaunch", "AppId=976310"), "")) + assertFalse(SteamGameProcess.matches(cmdline("reaper", "SteamLaunch", "AppId=976310"), "abc")) } @Test fun steamsReaperAndProtonAreAGame() { assertTrue(SteamGameProcess.matches(cmdline("/root/.local/share/Steam/steamrtarm64/reaper", "SteamLaunch", "AppId=976310", "--", - "/root/.local/share/Steam/compatibilitytools.d/droiddeck-proton-arm64/proton", "waitforexitandrun", "MK11.exe"))) - assertTrue(SteamGameProcess.matches(cmdline("python3", "/proton", "waitforexitandrun", "game.exe"))) + "/root/.local/share/Steam/compatibilitytools.d/droiddeck-proton-arm64/proton", "waitforexitandrun", "MK11.exe"), "976310")) + assertFalse(SteamGameProcess.matches(cmdline("/root/.local/share/Steam/steamrtarm64/reaper", "SteamLaunch", "AppId=976310", "--", + "/root/.local/share/Steam/compatibilitytools.d/droiddeck-proton-arm64/proton", "waitforexitandrun", "MK11.exe"), "123")) + assertFalse(SteamGameProcess.matches(cmdline("python3", "/proton", "waitforexitandrun", "game.exe"), "976310")) + } + + @Test fun shortcutCGameIdsMatchTheir32BitSteamAppId() { + val cgameId = ((976310L shl 32) or 0x02000000L).toString() + + assertTrue( + SteamGameProcess.matches( + cmdline("reaper", "SteamLaunch", "AppId=976310", "--", "proton", "waitforexitandrun", "game.exe"), + cgameId, + ) + ) + + assertTrue( + SteamGameProcess.matches( + cmdline("steam", "-applaunch", "976310"), + cgameId, + ) + ) + + assertFalse( + SteamGameProcess.matches( + cmdline("reaper", "SteamLaunch", "AppId=123", "--", "proton", "waitforexitandrun", "game.exe"), + cgameId, + ) + ) } @Test fun runningLooksAtEveryProcess() { @@ -31,8 +60,12 @@ class SteamGameProcessTest { fun process(pid: String, vararg args: String) = File(proc, pid).apply { mkdirs() }.resolve("cmdline").writeBytes(cmdline(*args)) process("100", "pgrep", "-a", "-f", "SteamLaunch AppId=[0-9]") process("self", "reaper", "SteamLaunch", "AppId=1") - assertFalse(SteamGameProcess.running(proc)) + assertFalse(SteamGameProcess.running("976310", proc)) + assertFalse(SteamGameProcess.running("1", proc)) + process("101", "reaper", "SteamLaunch", "AppId=1") + assertTrue(SteamGameProcess.running("1", proc)) process("200", "reaper", "SteamLaunch", "AppId=976310", "--", "proton", "waitforexitandrun", "MK11.exe") - assertTrue(SteamGameProcess.running(proc)) + assertTrue(SteamGameProcess.running("976310", proc)) + assertFalse(SteamGameProcess.running("123", proc)) } } diff --git a/app/src/test/java/com/droiddeck/launcher/session/TurnipEnvironmentTest.kt b/app/src/test/java/com/droiddeck/launcher/session/TurnipEnvironmentTest.kt new file mode 100644 index 0000000000..c452f7e64c --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/session/TurnipEnvironmentTest.kt @@ -0,0 +1,26 @@ +package com.droiddeck.launcher.session + +import org.junit.Assert.assertEquals +import org.junit.Test + +class TurnipEnvironmentTest { + @Test fun sysmemSettingAppliesToGames() { + assertEquals(listOf("DROIDDECK_GAME_TU_DEBUG=sysmem"), TurnipEnvironment.gameEnvironment(null, false, true, emptyList())) + } + + @Test fun disablingSysmemKeepsTheDriverDefault() { + assertEquals(listOf("DROIDDECK_GAME_TU_DEBUG="), TurnipEnvironment.gameEnvironment(null, false, false, emptyList())) + } + + @Test fun overrideWinsOverTheSetting() { + assertEquals(listOf("DROIDDECK_GAME_TU_DEBUG=nolrz"), TurnipEnvironment.gameEnvironment("nolrz", false, true, emptyList())) + } + + @Test fun sysmemDriverForcesSysmem() { + assertEquals(listOf("DROIDDECK_GAME_TU_DEBUG=sysmem"), TurnipEnvironment.gameEnvironment(null, true, false, emptyList())) + } + + @Test fun gameEnvironmentOverrideWins() { + assertEquals(emptyList(), TurnipEnvironment.gameEnvironment(null, false, true, listOf("TU_DEBUG=nolrz"))) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/stores/GogCloudKeysTest.kt b/app/src/test/java/com/droiddeck/launcher/stores/GogCloudKeysTest.kt index 025dbce9b8..d6667e2a12 100644 --- a/app/src/test/java/com/droiddeck/launcher/stores/GogCloudKeysTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/stores/GogCloudKeysTest.kt @@ -59,15 +59,193 @@ class GogCloudKeysTest { @Test fun putUploadsTheGogGzipBodyWithEncodingAndCompressedHash() { val raw = "savegame0".toByteArray() - val server = java.net.ServerSocket(0, 4, java.net.InetAddress.getByName("127.0.0.1")) - val requests = java.util.concurrent.CopyOnWriteArrayList() - val worker = Thread { - repeat(2) { + val requests = serve(2, ::okResponse) { url -> + val cloud = GogCloud("user", "client", "token", "saves", url) + val source = java.io.File.createTempFile("save", ".sav").apply { writeBytes(raw) } + val result = try { + cloud.putFiles(mapOf("save.sav" to source), mapOf("save.sav" to 1_793_490_825_000L)).getValue("save.sav") + } finally { + source.delete() + } + assertTrue(result.modifiedMs > 0) + assertEquals(CloudSaves.md5(raw), result.md5) + } + val put = requests[0] + assertEquals("PUT", put.method) + assertEquals("/v1/user/client/saves%2Fsave.sav", put.path) + assertEquals("gzip", put.headers["content-encoding"]) + assertEquals("2026-10-31T23:53:45+00:00", put.headers["x-object-meta-locallastmodified"]) + assertArrayEquals(gzipGogPut(raw), put.body) + assertEquals(CloudSaves.md5(put.body), put.headers["etag"]) + assertArrayEquals(raw, gogDecodeCloudBody(put.body, put.headers["content-encoding"])) + assertEquals("HEAD", requests[1].method) + } + + @Test fun putStagesInAMissingTempDirByCreatingIt() { + val root = java.nio.file.Files.createTempDirectory("gog-cloud-test").toFile() + val temp = java.io.File(root, "cache") + val source = java.io.File(root, "save.sav").apply { writeBytes("savegame0".toByteArray()) } + try { + val requests = serve(2, ::okResponse) { url -> + GogCloud("user", "client", "token", "saves", url, tempDir = temp).putFiles(mapOf("save.sav" to source)) + } + assertEquals("PUT", requests[0].method) + assertTrue(temp.isDirectory) + assertEquals(0, temp.listFiles()!!.size) + } finally { + temp.delete(); source.delete(); root.delete() + } + } + + @Test fun rejectedPutNamesStepStatusAndFileWithoutTheToken() { + val secret = "eyJhbGciOiJIUzI1NiJ9.c2VjcmV0LXRva2VuLXZhbHVlLWxvbmc.c2lnbmF0dXJl" + val source = java.io.File.createTempFile("save", ".sav").apply { writeBytes("savegame0".toByteArray()) } + try { + val failure = runCatching { + serve(1, { _ -> + val body = "{\"error\":\"invalid_grant\",\"access_token\":\"$secret\"}" + "HTTP/1.1 403 Forbidden\r\nContent-Length: ${body.length}\r\nConnection: close\r\n\r\n$body" + }) { url -> GogCloud("user", "client", secret, "saves", url).putFiles(mapOf("Save 3.ess" to source)) } + }.exceptionOrNull() + assertTrue(failure is java.io.IOException) + val detail = cloudFailureDetail(failure!!) + assertTrue(detail, detail.contains("GOG cloud put HTTP 403 file=Save 3.ess")) + assertTrue(detail, detail.contains("invalid_grant")) + assertFalse(detail, detail.contains(secret)) + } finally { + source.delete() + } + } + + @Test fun failureDetailKeepsTheCauseChainAndDropsCredentials() { + val e = java.io.IOException( + "GOG cloud put file=Save12_C2B8E7B0_0_507269736F6E6572_Tamriel_000027.ess bytes=10", + java.io.IOException("refused https://auth.gog.com/token?client_secret=abc&refresh_token=def Bearer xyz123", java.net.UnknownHostException("cloudstorage.gog.com")), + ) + val detail = cloudFailureDetail(e) + assertTrue(detail, detail.startsWith("IOException: GOG cloud put file=Save12_C2B8E7B0_0_507269736F6E6572_Tamriel_000027.ess")) + assertTrue(detail, detail.contains("IOException: refused auth.gog.com")) + assertTrue(detail, detail.endsWith("UnknownHostException: cloudstorage.gog.com")) + for (leak in listOf("abc", "def", "xyz123", "client_secret", "/token")) assertFalse(detail, detail.contains(leak)) + assertEquals("IOException", cloudFailureDetail(java.io.IOException())) + } + + @Test fun urlCredentialsAreDroppedAndOnlyTheHostIsKept() { + val scrubbed = scrubCloudText("see https://alice:shortpass@example.com/private?x=1 and http://bob@gog.com:443/a") + assertEquals("see example.com and gog.com:443", scrubbed) + assertEquals("cloudstorage.gog.com", scrubCloudText("https://cloudstorage.gog.com/v1/user/saves")) + } + + @Test fun errorSnippetReadsABoundedPrefixAndDropsATokenCutAtTheBoundary() { + val read = java.util.concurrent.atomic.AtomicLong() + val huge = object : java.io.InputStream() { + override fun read(): Int { read.incrementAndGet(); return 'a'.code } + override fun read(b: ByteArray, off: Int, len: Int): Int { + val prefix = "invalid_grant " + for (i in 0 until len) { + val at = read.getAndIncrement() + b[off + i] = (if (at < prefix.length) prefix[at.toInt()] else 'q').code.toByte() + } + return len + } + } + val snippet = cloudErrorSnippet(huge) + assertTrue(read.get() <= 4097) + assertEquals("invalid_grant", snippet) + val cut = " ".repeat(4090) + "pw=shortsecretvalue-continues" + assertEquals("", cloudErrorSnippet(cut.byteInputStream())) + assertEquals("pw=shortsecretvalue-continues", cloudErrorSnippet((" ".repeat(10) + "pw=shortsecretvalue-continues").byteInputStream())) + assertEquals("forbidden", cloudErrorSnippet("forbidden".byteInputStream())) + assertEquals("", cloudErrorSnippet(null)) + } + + @Test fun everyCloudRequestIdentifiesAsTheGalaxyCommunicationService() { + val raw = "savegame0".toByteArray() + val requests = serve(5, { request -> + when { + request.method == "GET" && request.path == "/v1/user/client" -> + "HTTP/1.1 200 OK\r\nContent-Length: 14\r\nConnection: close\r\n\r\nsaves/save.sav" + request.method == "GET" -> + "HTTP/1.1 200 OK\r\nContent-Length: ${raw.size}\r\nConnection: close\r\n\r\n${raw.decodeToString()}" + else -> okResponse(request) + } + }) { url -> + val cloud = GogCloud("user", "client", "token", "saves", url) + val file = cloud.list().single() + cloud.details(file) + assertArrayEquals(raw, cloud.get(file).first) + cloud.put(mapOf("save.sav" to raw), mapOf("save.sav" to 1_793_490_825_000L)) + } + assertEquals(listOf("GET", "HEAD", "GET", "PUT", "HEAD"), requests.map { it.method }) + requests.forEach { assertEquals(it.method, GOG_CLOUD_UA, it.headers["user-agent"]) } + assertTrue(GOG_CLOUD_UA.startsWith("GOGGalaxyCommunicationService/2.")) + assertEquals(GOG_CLOUD_UA, requests[3].headers["x-object-meta-user-agent"]) + requests.forEach { assertEquals("Bearer token", it.headers["authorization"]) } + } + + @Test fun rejectedListKeepsTheServerErrorInTheDetail() { + val body = "{\"error\":\"invalid_version\",\"error_description\":\"not supported with this version\"}" + val failure = runCatching { + serve(1, { "HTTP/1.1 400 Bad Request\r\nContent-Length: ${body.length}\r\nConnection: close\r\n\r\n$body" }) { url -> + GogCloud("user", "client", "token", "saves", url).list() + } + }.exceptionOrNull() + assertTrue(failure is java.io.IOException) + val detail = cloudFailureDetail(failure!!) + assertTrue(detail, detail.contains("GOG cloud list HTTP 400")) + assertTrue(detail, detail.contains("invalid_version")) + } + + @Test fun disabledListErrorsRemainRecognized() { + for (error in listOf("disabled", "not_enabled_for_client")) { + for (padding in listOf("", ",\"padding\":\"${"x".repeat(100_000)}\"")) { + val body = "{\"error\":\"$error\"$padding}" + val failure = runCatching { + serve(1, { "HTTP/1.1 403 Forbidden\r\nContent-Length: ${body.length}\r\nConnection: close\r\n\r\n$body" }, allowEarlyClose = padding.isNotEmpty()) { url -> + GogCloud("user", "client", "token", "saves", url).list() + } + }.exceptionOrNull() + assertTrue("$error: $failure", failure is NoCloudSaves) + } + } + } + + @Test fun largeListErrorIsBoundedAndSanitized() { + val body = "invalid_version " + "x".repeat(100_000) + val failure = runCatching { + serve(1, { "HTTP/1.1 400 Bad Request\r\nContent-Length: ${body.length}\r\nConnection: close\r\n\r\n$body" }, allowEarlyClose = true) { url -> + GogCloud("user", "client", "token", "saves", url).list() + } + }.exceptionOrNull() + assertTrue("$failure", failure is java.io.IOException) + assertTrue(failure!!.message!!.contains("invalid_version")) + assertTrue(failure.message!!.length < 200) + } + + @Test fun failedResultLineCarriesTheDetailAndOtherLinesAreUnchanged() { + assertEquals("result=failed files=0 bytes=0 reason=IOException detail=\"IOException: x\"", + CloudSaves.Result("failed", 0, 0, "IOException", detail = "IOException: x").line) + assertEquals("result=ok files=1 bytes=2 reason=uploaded conflicts=3", CloudSaves.Result("ok", 1, 2, "uploaded", 3).line) + } +} + +private fun okResponse(request: Request): String = + if (request.method == "PUT") "HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n" + else "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n" + + "Etag: \"${CloudSaves.md5(request.body)}\"\r\n" + + "Last-Modified: Tue, 20 Oct 2026 10:00:00 GMT\r\nConnection: close\r\n\r\n" + +private fun serve(count: Int, respond: (Request) -> String, allowEarlyClose: Boolean = false, block: (String) -> Unit): List { + val server = java.net.ServerSocket(0, 4, java.net.InetAddress.getByName("127.0.0.1")) + val requests = java.util.concurrent.CopyOnWriteArrayList() + val failure = java.util.concurrent.atomic.AtomicReference() + val worker = Thread { + try { + repeat(count) { server.accept().use { client -> client.soTimeout = 5_000 val input = client.getInputStream() - val line = readLine(input) - val parts = line.split(' ') + val parts = readLine(input).split(' ') val headers = LinkedHashMap() while (true) { val h = readLine(input) @@ -83,42 +261,36 @@ class GogCloudKeysTest { if (n < 0) break offset += n } - requests += Request(parts[0], parts[1], headers, body) - val response = if (parts[0] == "PUT") { - "HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n" - } else { - "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n" + - "Etag: \"${CloudSaves.md5(body)}\"\r\n" + - "Last-Modified: Tue, 20 Oct 2026 10:00:00 GMT\r\nConnection: close\r\n\r\n" + val request = Request(parts[0], parts[1], headers, body) + requests += request + val response = respond(request).toByteArray() + try { + client.getOutputStream().apply { write(response); flush() } + } catch (e: java.io.IOException) { + if (!allowEarlyClose) throw e } - client.getOutputStream().apply { write(response.toByteArray()); flush() } } } - }.apply { isDaemon = true; start() } - try { - val cloud = GogCloud("user", "client", "token", "saves", "http://127.0.0.1:${server.localPort}/v1/user/client") - val source = java.io.File.createTempFile("save", ".sav").apply { writeBytes(raw) } - val result = try { - cloud.putFiles(mapOf("save.sav" to source), mapOf("save.sav" to 1_793_490_825_000L)).getValue("save.sav") - } finally { - source.delete() - } - assertTrue(result.modifiedMs > 0) - assertEquals(CloudSaves.md5(raw), result.md5) - val put = requests[0] - assertEquals("PUT", put.method) - assertEquals("/v1/user/client/saves%2Fsave.sav", put.path) - assertEquals("gzip", put.headers["content-encoding"]) - assertEquals("2026-10-31T23:53:45+00:00", put.headers["x-object-meta-locallastmodified"]) - assertArrayEquals(gzipGogPut(raw), put.body) - assertEquals(CloudSaves.md5(put.body), put.headers["etag"]) - assertArrayEquals(raw, gogDecodeCloudBody(put.body, put.headers["content-encoding"])) - assertEquals("HEAD", requests[1].method) - } finally { - server.close() - worker.join(2_000) + } catch (t: Throwable) { + failure.set(t) } + }.apply { isDaemon = true; start() } + val result = runCatching { + block("http://127.0.0.1:${server.localPort}/v1/user/client") } + val cleanup = runCatching { + server.close() + worker.join(2_000) + check(!worker.isAlive) { "Server worker did not finish" } + failure.get()?.let { throw AssertionError("Server worker failed", it) } + check(requests.size == count) { "Expected $count requests, received ${requests.size}" } + } + result.exceptionOrNull()?.let { primary -> + cleanup.exceptionOrNull()?.let { primary.addSuppressed(it) } + throw primary + } + cleanup.getOrThrow() + return requests } private class Request(val method: String, val path: String, val headers: Map, val body: ByteArray) diff --git a/app/src/test/java/com/droiddeck/launcher/stores/epic/EpicLibraryTest.kt b/app/src/test/java/com/droiddeck/launcher/stores/epic/EpicLibraryTest.kt index a3f156e1b0..96876bf5b1 100644 --- a/app/src/test/java/com/droiddeck/launcher/stores/epic/EpicLibraryTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/stores/epic/EpicLibraryTest.kt @@ -30,6 +30,29 @@ class EpicLibraryTest { assertEquals(listOf(game), EpicLibrary.fromCacheJson(text)) } + @Test fun thirdPartyLauncherIsCarriedToCatalogItems() { + val game = EpicLibrary.gameFrom( + JSONObject().put("appName", "Fig").put("namespace", "ns").put("catalogItemId", "cat"), + JSONObject().put("thirdPartyManagedApp", "EA app"), + null, + ) + assertEquals("EA app", game.thirdPartyManagedApp) + assertEquals("EA app", EpicLibrary.toCatalogItem(app, game).extra["thirdPartyManagedApp"]) + } + + @Test fun catalogDetailsClearTheCachedThirdPartyLauncher() { + val record = JSONObject().put("appName", "Fig").put("namespace", "ns").put("catalogItemId", "cat") + val before = EpicGame("Fig", "ns", "cat", "Fig", thirdPartyManagedApp = "EA app") + val fresh = EpicLibrary.gameFrom(record, JSONObject().put("thirdPartyManagedApp", ""), before) + assertEquals("", fresh.thirdPartyManagedApp) + assertEquals("", EpicLibrary.toCatalogItem(app, fresh).extra["thirdPartyManagedApp"]) + assertEquals(listOf(fresh), EpicLibrary.fromCacheJson(EpicLibrary.toCacheJson(listOf(fresh)))) + assertEquals("", EpicLibrary.gameFrom(record, JSONObject(), before).thirdPartyManagedApp) + assertEquals("Ubisoft Connect", EpicLibrary.gameFrom(record, + JSONObject().put("thirdPartyManagedApp", "Ubisoft Connect"), before).thirdPartyManagedApp) + assertEquals("EA app", EpicLibrary.gameFrom(record, null, before).thirdPartyManagedApp) + } + @Test fun readingSkipsDedupsSortsAndCapsSizes() { val text = JSONArray() .put(JSONObject().put("appName", "b").put("title", "beta").put("installSize", (1L shl 41))) @@ -55,7 +78,7 @@ class EpicLibraryTest { assertEquals("Hi", item.description) assertTrue(item.owned) assertEquals("https://store.epicgames.com/en-US/browse?q=Fig+%26+Co", item.storeUrl) - assertEquals(mapOf("namespace" to "ns", "catalogItemId" to "cat", "version" to ""), item.extra) + assertEquals(mapOf("namespace" to "ns", "catalogItemId" to "cat", "version" to "", "thirdPartyManagedApp" to ""), item.extra) val old = EpicLibrary.toCatalogItem(app, EpicGame("Old", "ns", "c", "Old", artSquare = "wide", installSize = 9L)) assertEquals("2001", old.releaseDate) assertEquals(9L, old.sizeBytes) diff --git a/app/src/test/java/com/droiddeck/launcher/ui/InputSurfaceTouchTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/InputSurfaceTouchTest.kt index 27f0669620..3df8d65e0f 100644 --- a/app/src/test/java/com/droiddeck/launcher/ui/InputSurfaceTouchTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/ui/InputSurfaceTouchTest.kt @@ -98,6 +98,24 @@ class InputSurfaceTouchTest { assertFalse(state().isDown(PadState.A)) } + @Test fun aPenPressesButtonsLikeAFingerAndItsMissesKeepTheirHistory() { + touch(MotionEvent.ACTION_DOWN, 1 to (800f to 240f), tool = MotionEvent.TOOL_TYPE_STYLUS) + assertTrue(state().isDown(PadState.A)) + touch(MotionEvent.ACTION_UP, 1 to (800f to 240f), tool = MotionEvent.TOOL_TYPE_STYLUS) + assertFalse(state().isDown(PadState.A)) + val missed = mutableListOf>() + view.onTouchMiss = { event -> missed += (0 until event.historySize).map { event.getHistoricalEventTime(it) } + event.eventTime } + touch(MotionEvent.ACTION_DOWN, 1 to (500f to 100f), tool = MotionEvent.TOOL_TYPE_STYLUS) + val properties = arrayOf(MotionEvent.PointerProperties().apply { id = 1; toolType = MotionEvent.TOOL_TYPE_STYLUS }) + fun coords(x: Float) = arrayOf(MotionEvent.PointerCoords().apply { this.x = x; y = 100f; pressure = 0.5f }) + val move = MotionEvent.obtain(1000L, 2000L, MotionEvent.ACTION_MOVE, 1, properties, coords(510f), 0, 0, 1f, 1f, 0, 0, 0, 0) + move.addBatch(2003L, coords(520f), 0) + move.addBatch(2006L, coords(530f), 0) + try { view.dispatchTouchEvent(move) } finally { move.recycle() } + assertEquals(listOf(listOf(time - 1), listOf(2000L, 2003L, 2006L)), missed) + assertFalse(state().isDown(PadState.A)) + } + @Test fun keyboardShortcutOpensOnRelease() { touch(MotionEvent.ACTION_DOWN, 1 to (450f to 510f)) assertTrue(events.isEmpty()) diff --git a/app/src/test/java/com/droiddeck/launcher/ui/PenSettingsGroupTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/PenSettingsGroupTest.kt new file mode 100644 index 0000000000..cc416ce52c --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/ui/PenSettingsGroupTest.kt @@ -0,0 +1,99 @@ +package com.droiddeck.launcher.ui + +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.verticalScroll +import androidx.compose.runtime.mutableStateOf +import androidx.compose.ui.Modifier +import androidx.compose.ui.test.* +import com.droiddeck.launcher.R +import com.droiddeck.launcher.gpu.FrameGen +import com.droiddeck.launcher.gpu.Lossless +import com.droiddeck.launcher.input.SecondScreenMode +import com.droiddeck.launcher.session.SessionPrefs +import com.droiddeck.launcher.session.SessionService +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], qualifiers = "w800dp-h600dp") +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class PenSettingsGroupTest { + @get:Rule val compose = createRobolectricComposeRule() + private val context get() = RuntimeEnvironment.getApplication() + + @Test fun theDrawerHasNoPenGroupUntilAPenIsKnown() { + compose.setContent { DroidDeckTheme { SessionDrawer(true, SessionDrawerPage.CONTROLLER, false, {}, actions(pen = null)) } } + compose.onNodeWithTag("setting-touch").assertExists() + compose.onNodeWithTag("setting-pen").assertDoesNotExist() + compose.onNodeWithTag("setting-pen-button").assertDoesNotExist() + } + + @Test fun theDrawerSavesPenPicks() { + val picks = mutableListOf>() + compose.setContent { + DroidDeckTheme { + SessionDrawer(true, SessionDrawerPage.CONTROLLER, false, {}, actions(SessionPrefs.Pen()) { k, v -> picks += k to v }) + } + } + compose.onNodeWithTag("setting-pen-button").performScrollTo().performClick() + compose.onNodeWithText(context.getString(R.string.gesture_middle_click)).performScrollTo().performClick() + compose.onNodeWithTag("setting-pen").performScrollTo().performClick() + compose.onNodeWithText(context.getString(R.string.mode_pen_touch)).performScrollTo().performClick() + compose.runOnIdle { + assertEquals(listOf("penButton" to SessionPrefs.PEN_BUTTON_MIDDLE, "pen" to SessionPrefs.PEN_TOUCH), picks) + } + } + + @Test fun theSideButtonRowIsHiddenInTouchMode() { + val pen = mutableStateOf(SessionPrefs.Pen()) + compose.setContent { DroidDeckTheme { Column { PenSettingsGroup(rememberMenuHost(), pen.value) { _, _ -> } } } } + compose.onNodeWithTag("setting-pen-button").assertExists() + compose.runOnIdle { pen.value = SessionPrefs.Pen(mode = SessionPrefs.PEN_TOUCH) } + compose.onNodeWithTag("setting-pen").assertExists() + compose.onNodeWithTag("setting-pen-button").assertDoesNotExist() + } + + @Test fun theControlsTabShowsThePenGroupAfterTheTouchRowsOnceAPenIsKnown() { + val pen = mutableStateOf(null) + val picks = mutableListOf>() + compose.setContent { + DroidDeckTheme { + Column(Modifier.verticalScroll(rememberScrollState())) { + ModeSheetRows(ModeSettings(mode = SessionService.MODE_DESKTOP, resolution = "auto", hdr = false, hdrReason = null, + touchMode = "auto", pen = pen.value, suspendPolicy = "auto", oscMode = "auto", directAudio = null, mic = null), + ModeSettingsActions(onResolution = {}, onHdr = {}, onTouch = {}, onPen = { k, v -> picks += k to v }, + onSuspendPolicy = {}, onOsc = {}, onInputSettings = {}, onDirectAudio = {}, onMic = {}, onDismiss = {}), + SheetTab.CONTROLS) + } + } + } + compose.onNodeWithTag("setting-touch").assertExists() + compose.onNodeWithTag("setting-pen").assertDoesNotExist() + compose.runOnIdle { pen.value = SessionPrefs.Pen() } + compose.onNodeWithTag("setting-pen-button").assertExists() + assertTrue(compose.onNodeWithTag("setting-touch").fetchSemanticsNode().positionInRoot.y < + compose.onNodeWithTag("setting-pen").fetchSemanticsNode().positionInRoot.y) + compose.onNodeWithTag("setting-pen-button").performScrollTo().performClick() + compose.onNodeWithText(context.getString(R.string.gesture_middle_click)).performScrollTo().performClick() + compose.runOnIdle { assertEquals(listOf("penButton" to SessionPrefs.PEN_BUTTON_MIDDLE), picks) } + } + + private fun actions(pen: SessionPrefs.Pen?, onPen: (String, String) -> Unit = { _, _ -> }) = + DrawerActions(steam = false, desktop = true, isHomeApp = false, androidApps = emptyList(), hudOn = false, + frameGen = FrameGen.Mode.OFF, lossless = Lossless.State.NONE, oscMode = "never", + suspendPolicy = "auto", backActionsInverted = false, + touchMode = "auto", touchAuto = "touchpad", pen = pen, onPen = onPen, fexPreset = "default", + secondScreenMode = SecondScreenMode.NONE, secondScreenDisplays = emptyList(), selectedSecondScreenDisplay = 1, + onHud = {}, onFrameGenPick = {}, onImportLossless = {}, onKeyboard = {}, onHardwareKeyboard = {}, + onSteamMenu = null, onQam = null, onOsc = {}, onSuspendPolicy = {}, onBackActionsInverted = {}, + onTouch = {}, onFexPreset = {}, onSecondScreenMode = {}, onSecondScreenDisplay = {}, + onLaunchAndroidApp = { _, _ -> }, onBackground = {}, onShareLogs = {}, onStop = {}, onClose = {}) +} diff --git a/app/src/test/java/com/droiddeck/launcher/ui/PresentationWindowTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/PresentationWindowTest.kt new file mode 100644 index 0000000000..ca76cd6d75 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/ui/PresentationWindowTest.kt @@ -0,0 +1,185 @@ +package com.droiddeck.launcher.ui + +import android.app.Presentation +import android.hardware.display.DisplayManager +import android.os.Looper +import android.view.Display +import androidx.activity.ComponentActivity +import androidx.activity.setViewTreeOnBackPressedDispatcherOwner +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.runtime.SideEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.compose.ui.platform.ComposeView +import androidx.compose.ui.platform.LocalView +import androidx.compose.ui.test.assert +import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.click +import androidx.compose.ui.test.hasAnyAncestor +import androidx.compose.ui.test.isDialog +import androidx.compose.ui.test.isPopup +import androidx.compose.ui.test.onNodeWithText +import androidx.compose.ui.test.percentOffset +import androidx.compose.ui.test.performClick +import androidx.compose.ui.test.performTouchInput +import androidx.compose.ui.window.DialogProperties +import androidx.lifecycle.setViewTreeLifecycleOwner +import androidx.lifecycle.setViewTreeViewModelStoreOwner +import androidx.savedstate.setViewTreeSavedStateRegistryOwner +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config +import org.robolectric.shadows.ShadowDisplayManager + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], qualifiers = "w640dp-h480dp-land", application = android.app.Application::class) +class PresentationWindowTest { + private companion object { const val FRAMES = 5 } + + @get:Rule val compose = createRobolectricComposeRule() + + private fun showOutsideTapPopup(content: @Composable () -> Unit) { + compose.mainClock.autoAdvance = false + compose.setContent { CompositionLocalProvider(LocalPresentationWindow provides true, content = content) } + repeat(FRAMES) { compose.mainClock.advanceTimeByFrame() } + } + + private fun tapOutsidePopup() { + compose.onNode(isPopup()).performTouchInput { click(percentOffset(.99f, .99f)) } + repeat(FRAMES) { compose.mainClock.advanceTimeByFrame() } + } + + @Test fun alertInsidePresentationRendersDismissesAndTracksItsWindow() { + var shown by mutableStateOf(true) + var displayId = Display.DEFAULT_DISPLAY + compose.setContent { + CompositionLocalProvider(LocalPresentationWindow provides true) { + val view = LocalView.current + SideEffect { displayId = view.display?.displayId ?: Display.DEFAULT_DISPLAY } + if (shown) GlideAlertDialog( + onDismissRequest = { shown = false }, + confirmButton = { TextButton(onClick = { shown = false }) { Text("Confirm") } }, + title = { Text("Title") }, + text = { Text("Body") }, + ) + } + } + compose.onNodeWithText("Title").assertIsDisplayed() + .assert(hasAnyAncestor(isPopup())) + compose.onNodeWithText("Body").assertIsDisplayed() + compose.onNode(isDialog()).assertDoesNotExist() + compose.runOnIdle { assertNotNull(KeyWindows.topOn(displayId)) } + compose.onNodeWithText("Confirm").performClick() + compose.onNodeWithText("Title").assertDoesNotExist() + } + + @Test fun dialogInsidePresentationRendersItsContent() { + var shown by mutableStateOf(true) + compose.setContent { + CompositionLocalProvider(LocalPresentationWindow provides true) { + if (shown) GlideDialog(onDismissRequest = { shown = false }) { + TextButton(onClick = { shown = false }) { Text("Close") } + } + } + } + compose.onNodeWithText("Close").assertIsDisplayed() + .assert(hasAnyAncestor(isPopup())) + compose.onNode(isDialog()).assertDoesNotExist() + compose.onNodeWithText("Close").performClick() + compose.onNodeWithText("Close").assertDoesNotExist() + } + + @Test fun dialogInsidePresentationDismissesOnOutsideTapByDefault() { + var shown by mutableStateOf(true) + showOutsideTapPopup { if (shown) GlideDialog(onDismissRequest = { shown = false }) { Text("Panel") } } + tapOutsidePopup() + compose.onNodeWithText("Panel").assertDoesNotExist() + } + + @Test fun dialogInsidePresentationHonorsDisabledOutsideDismissal() { + var dismissals = 0 + showOutsideTapPopup { + GlideDialog( + onDismissRequest = { dismissals++ }, + properties = DialogProperties(dismissOnClickOutside = false), + ) { Text("Panel") } + } + tapOutsidePopup() + compose.onNodeWithText("Panel").assertIsDisplayed() + assertEquals(0, dismissals) + } + + @Test + @Config(sdk = [33]) + fun dialogUsesThePresentationWindowOnAndroid13() { + val activityController = Robolectric.buildActivity(ComponentActivity::class.java).setup() + val activity = activityController.get() + val displays = activity.getSystemService(DisplayManager::class.java) + val displayId = ShadowDisplayManager.addDisplay("w640dp-h480dp-land") + val display = displays.getDisplay(displayId) + shadowOf(display).setFlags(Display.FLAG_PRESENTATION) + var dialogComposed = false + val presentation = Presentation(activity, display) + val view = ComposeView(presentation.context).apply { + setViewTreeLifecycleOwner(activity) + setViewTreeViewModelStoreOwner(activity) + setViewTreeSavedStateRegistryOwner(activity) + setViewTreeOnBackPressedDispatcherOwner(activity) + setContent { + CompositionLocalProvider(LocalPresentationWindow provides true) { + DroidDeckTheme { + GlideDialog(onDismissRequest = {}) { + SideEffect { dialogComposed = true } + Text("Panel") + } + } + } + } + } + presentation.setContentView(view) + try { + presentation.show() + shadowOf(Looper.getMainLooper()).idle() + assertTrue(dialogComposed) + compose.onNodeWithText("Panel").assertIsDisplayed() + .assert(hasAnyAncestor(isPopup())) + compose.onNode(isDialog()).assertDoesNotExist() + } finally { + presentation.dismiss() + activityController.pause().stop().destroy() + } + } + + @Test fun dialogOutsidePresentationKeepsThePlatformDialog() { + compose.setContent { GlideDialog(onDismissRequest = {}) { Text("Panel") } } + compose.onNodeWithText("Panel").assertIsDisplayed() + .assert(hasAnyAncestor(isDialog())) + compose.onNode(isPopup()).assertDoesNotExist() + } + + @Test fun alertOutsidePresentationKeepsThePlatformDialog() { + compose.setContent { + GlideAlertDialog( + onDismissRequest = {}, + confirmButton = { TextButton(onClick = {}) { Text("Confirm") } }, + title = { Text("Title") }, + text = { Text("Body") }, + ) + } + compose.onNodeWithText("Title").assertIsDisplayed() + .assert(hasAnyAncestor(isDialog())) + compose.onNodeWithText("Body").assertIsDisplayed() + compose.onNode(isPopup()).assertDoesNotExist() + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/ui/ThemeColorsTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/ThemeColorsTest.kt index fdbb8b44be..2f2cc3cd3b 100644 --- a/app/src/test/java/com/droiddeck/launcher/ui/ThemeColorsTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/ui/ThemeColorsTest.kt @@ -168,4 +168,24 @@ class ThemeColorsTest { Themes.setRgbSpeed(app, 1) assertTrue(Themes.rgbCycleMillis(1) > Themes.rgbCycleMillis(10)) } + + @Test fun trueBlackKeepsThePageAndPanelsBlackWhateverTheHighlight() { + for (highlight in listOf(0xFF1A9FFF, 0xFFFF0000, 0xFF00FF66, 0xFFFFFFFF, 0xFF000000, 0xFF00008B, 0xFFFFE600)) { + val p = ThemeColors.trueBlack(highlight.toInt()) + assertEquals(Color.Black, p.background) + assertEquals(Color.Black, p.surface) + assertTrue("button text on $highlight", contrast(p.onPrimary, p.primary) >= 4.5f) + assertTrue("highlight $highlight shows on black", contrast(p.primary, Color.Black) >= 3f) + } + } + + @Test fun trueBlackFollowsTheSavedHighlightAndComesBackAfterARestart() { + assertEquals(Themes.TRUE_BLACK, Themes.byId(Themes.TRUE_BLACK).id) + Themes.setTrueBlackHighlight(app, 0xFFFF8800.toInt()) + assertEquals(Color(0xFFFF8800), Themes.byId(Themes.TRUE_BLACK).primary) + Themes.setTrueBlackHighlight(app, Themes.DEFAULT_HIGHLIGHT) + SessionPrefs.setTrueBlackHighlight(app, 0xFFFF8800.toInt()) + SessionPrefs.setTheme(app, Themes.TRUE_BLACK) + assertEquals(Color(0xFFFF8800), Themes.current(app).primary) + } } diff --git a/docs/agent-control.md b/docs/agent-control.md index 4ac8706706..dc9ced7e60 100644 --- a/docs/agent-control.md +++ b/docs/agent-control.md @@ -122,6 +122,10 @@ tools/droiddeckctl input swipe 100 600 100 100 --duration 400 tools/droiddeckctl input pad a tools/droiddeckctl input stick left 0 -1 --hold 500 tools/droiddeckctl input trigger right 1.0 +tools/droiddeckctl input pen tap 0.5 0.5 --pressure 0.7 +tools/droiddeckctl input pen stroke 0.2 0.5 0.8 0.5 --pressure 0.1:0.9 --tilt-x=-30:30 +tools/droiddeckctl input pen hover 0.3 0.5 --to 0.7 0.5 --duration 600 +tools/droiddeckctl input pen button primary 0.5 0.5 tools/droiddeckctl ui dump tools/droiddeckctl ui click rail-steam @@ -196,6 +200,20 @@ virtual pad, the same one the on-screen controls drive, so games that ignore tou `launch`, `quit` and `cdp` need a Steam session; `focus` and `wait focused` need gamescope (every mode except the desktop). +`input pen` does not go through the app. It registers a virtual pen with `adb shell uinput -`, so +Android's own input reader makes the stylus events, as for a built-in pen, and it works on whatever +is on screen, without a session or Setup > Developer > Debugging tools. Positions are fractions of +the screen as shown; `dumpsys input` gives the frame, rotation and size of the display Android maps +internal touchscreens to. `hover` comes near and glides to `--to`; `tap`, `stroke` and `button` +hover for `--hover-ms` (80) before and after the touch or the button press. Each takes +`--tool pen|eraser`, `--tilt-x` and `--tilt-y` in degrees, `--distance` in device units (0 to 255) +and `--rate` (120 samples a second); `--pressure` and tilt take `FROM:TO` ranges, written +`--tilt-x=-30:30` when they start negative. A gesture lasts at most 30 s. `UINPUT_UNAVAILABLE` +means the shell has no `uinput` or cannot write `/dev/uinput`, `NO_VIEWPORT` that there is no +internal display or it is off, and `UINPUT_FAILED` that `uinput` stopped early; all three exit 3. +It needs Android 14 QPR2 or later: the `uinput` of Android 12 to 14 QPR1 takes only numeric codes +and the USB or Bluetooth bus, so there the pen ends with `UINPUT_FAILED`. + ## State (schema 2) `state` returns `schema`, `build`, `appVersion`, `runtime {installed, version}`, diff --git a/docs/development/game-environment.md b/docs/development/game-environment.md index 5fb2f1be40..ac7be74c62 100644 --- a/docs/development/game-environment.md +++ b/docs/development/game-environment.md @@ -283,7 +283,12 @@ DroidDeck instead publishes an atomic JSON snapshot at `/root/.config/droiddeck/game-environment.json`. Both its Valve ARM64 Proton wrapper and adopted third-party Proton wrappers execute `droiddeck-game-env`, which reads that snapshot for each real game launch and uses `execvpe` to start -Proton. Probe prefix `compatdata/0` and non-launch verbs are unchanged. Malformed +Proton. Probe prefix `compatdata/0` and non-launch verbs are unchanged. A game launch +adds `tabtip.exe=d` to `WINEDLLOVERRIDES` unless the launch has `SteamDeck=1` +or the overrides already set `tabtip.exe` (also as `*tabtip.exe` or +`tabtip.exe.dll`): Proton's tabtip only opens Steam's +keyboard with `SteamDeck=1`, but it always runs UI Automation queries inside the +focused game, which crash games that answer them (Godot 4.5 AccessKit). Malformed configuration falls back to the inherited environment without evaluating its contents. Both component and environment selection normalize signed non-Steam prefix IDs to unsigned IDs. diff --git a/docs/development/low-memory.md b/docs/development/low-memory.md index 81055ff0b1..770fc80d11 100644 --- a/docs/development/low-memory.md +++ b/docs/development/low-memory.md @@ -52,6 +52,9 @@ percentage: Android's `lmkd` killed a session on a 7.5 GiB device with kill. A world load added 1 GiB of GPU memory in about ten seconds, and compressing 1.4 GiB took 2.6 seconds, so the request has to leave room for both. +Performance > Compress idle game memory turns this off (`BL_ZRAM_IDLE=0`); launcher compression +and the RAM cap are unaffected. + The session request runs when real headroom falls below a quarter of RAM (bounded to 768–2560 MiB), or below one and a half times that with at least 1% `some` or `full avg10` memory stall. Real headroom subtracts positive growth in KGSL allocation, `Unevictable`, and diff --git a/docs/development/mali-venus.md b/docs/development/mali-venus.md index 8a722ff7e0..fa72294e42 100644 --- a/docs/development/mali-venus.md +++ b/docs/development/mali-venus.md @@ -122,11 +122,16 @@ What it does, per feature: - The source must be memory the application has mapped; DXVK's staging memory is. - Decoded texels go through the layer's own staging buffers, recycled when the command buffer is reset. - Copies from a BC image into a buffer, and between BC and uncompressed images, are skipped with a warning. +- `dualSrcBlend`: reports maxFragmentDualSrcAttachments 1. DXVK 2.x and 3.x require it for D3D11. + - Fragment outputs with `Index 1` become Private, in shader modules and in inline stage code. + - SRC1 blend factors become source alpha: `SRC1_COLOR` and `SRC1_ALPHA` → `SRC_ALPHA`, their `ONE_MINUS_` forms → `ONE_MINUS_SRC_ALPHA`. + - Pipelines and `vkCmdSetColorBlendEquationEXT` both. + - Why alpha: output 0's color is the paint, its alpha is the usual coverage. Per-channel coverage collapses to one value; blending stays plain alpha blending, not tinted by the paint. Files: - `layer.c`: loader plumbing, feature and limit reporting, device creation, the hook table. - `pipeline.c`: pipelines, shader modules, viewports. -- `spirv.c`: the SPIR-V rewriter for clip and cull distances. +- `spirv.c`: the SPIR-V rewriter for clip and cull distances and the second blend source. - `bc.c`: BC formats, images and uploads. - `VkLayer_droiddeck_mali_compat.json`: implicit layer manifest. @@ -142,7 +147,8 @@ How it ships: - Guest paths: `usr/local/lib/droiddeck-mali/` and `usr/local/share/vulkan/implicit_layer.d/`. Not done yet: -- Unit tests for the SPIR-V rewriter. It is untested beyond DXVK's shaders, and unknown whether Silksong's shaders used clip distances at all. +- Unit tests for the clip and cull distance rewriter. It is untested beyond DXVK's shaders, and unknown whether Silksong's shaders used clip distances at all. + - The dual-source rewrite has them: `tools/tests/test_mali_compat_layer.py`. - Performance: BC decoding on the CPU makes loads slow. A compute-shader decoder would be the next step. ## Changes on the branch diff --git a/docs/development/pen.md b/docs/development/pen.md new file mode 100644 index 0000000000..67da1d91d4 --- /dev/null +++ b/docs/development/pen.md @@ -0,0 +1,91 @@ +# Pen input + +A pen on the phone's screen, or an external drawing tablet, drives the session's pointer like a mouse: hover moves +the pointer, the tip holds the left button and the side button right-clicks. Fingers keep their touch mode. + +The settings are a "Pen" group after the touch settings, in the Steam and Desktop sheets' **Controls** tab and on +the session drawer's **Controller** page. The group is shown once the phone has a stylus device or a pen event was +seen; the first of either sets `penSeen`, which a settings reset keeps. Before Android 14 every touchscreen whose +driver reports a tool type has the stylus source, pen or not, so there a touchscreen counts only with its first pen +event. + +## Modes + +`pen`: Mouse (default) or Touch. + +| | Mouse | Touch | +|---|---|---| +| Hover | moves the pointer and the cursor | ignored | +| Tip | holds the left button | a finger in the current touch mode | +| Side button | as the Side button setting says | ignored; a Bluetooth pen key is an ordinary key | + +- With the picture on the glasses, or while a program in gamescope holds a pointer lock, Mouse drives the touchpad + as a finger does: a tap clicks and a drag moves the pointer relatively. +- App UI on top (the drawer, achievements, input settings, picture in picture) takes the pen as Android input, as + it takes a mouse. +- The Touch column is for a pen on the phone's screen. In Touch an external tablet stays on the mouse path, so its + hover moves the pointer. The stylus rules under Android capture apply in both modes. +- A touch mode change ends the pen whatever its route, so it cannot leave a pen click held + ([#318](https://github.com/Droid-Deck/DroidDeck/issues/318)). + +## Side button + +`penButton`: Right click (default), Middle click or Off. It applies to the pen's first barrel button. A second +barrel button, where a pen has one, sends the other click: middle when the setting is Right click, right otherwise. +Off sends nothing. The row is hidden in Touch. + +Some pens send their button as a key from a separate Bluetooth keyboard; the OPPO AI Pen sends `KEYCODE_F21`. Such a +key is the side button when its device is external, keyboard-only and not alphabetic, and has a word starting with +"pen" or "stylus" in its name. In Mouse the pen always takes it, so neither the program nor the key bindings see +it, and it acts only while the pen is near: a key held when the pen comes back presses the button. Pause, focus +loss, pointer-capture loss and removing its device forget it. In Touch it is an ordinary key. + +## Android capture + +- Pens are found by tool type (stylus or eraser), or by `SOURCE_STYLUS` when the tool type is unknown. External + tablets report `SOURCE_MOUSE | SOURCE_STYLUS`, so the source alone is not enough. Events that mix a finger and a + pen are split, and the finger keeps its route. +- Contact is taken at the top of `SessionActivity.onTouchEvent`, after the Compose UI and the on-screen controls + declined it, so the pen presses on-screen buttons like a finger. Hover is taken in `dispatchGenericMotionEvent` + before the mouse branch. The lower-screen game takes both. +- With Low latency mode on (the default) the window asks for unbuffered pointer dispatch, so pen samples are not + batched per frame. Every historical sample is forwarded in order, and `pointerSubset` keeps the history when it + splits an event. +- `PenStream` keeps proximity, tip and buttons. A `HOVER_EXIT` followed within 50 ms by a hover or a `DOWN` does not + leave proximity: Android splits a landing into an exit and a down with the same time, and a digitizer can flicker + out and in at the top of its hover range. A hover that sends no sample for 2 s leaves proximity. +- Stylus devices are not hardware mice, so a drawing tablet does not turn on pointer capture. +- On the desktop a hardware mouse makes KWin grab the pointer. A pen that comes near releases the grab, so it + moves KWin's pointer, and the mouse takes the grab back when it moves after the pen has left. +- Where the session hides the mouse pointer it also hides Android's stylus hover icon. + +## What ends the pen + +Everything that cancels touches: touch mode, touch route and pen setting changes, app UI opening, configuration +changes, surface resize, the game moving between screens, picture in picture, pause, focus loss, pointer-capture +loss and the activity's end. So do a change of the pen's own route and the removal of its device. `UP` with +`FLAG_CANCELED` and `ACTION_CANCEL` end it at once instead of lifting into hover. Ending the pen releases every +button and leaves proximity; `wl_pointer` has no cancel, so on the pointer a cancelled tap still clicks. + +## Compositor + +Each sample is one input record, type 13: the flags (in proximity, tip, right, middle) and the position in input +space as 24.8 fixed point. A record is the pen's whole state, so the next record makes good any lost one. + +`deliver_pen` emulates the pointer, as the touch `pointer_fallback` does: hover is motion, the tip is `BTN_LEFT`, +the side button `BTN_RIGHT` or `BTN_MIDDLE`, and a record without the in-proximity bit releases every button. A +button pressed or released mid-stroke keeps the implicit grab on the window the stroke started in. The +relative-motion origin is reset when the pen comes and goes, so its jump never reaches a program as relative +motion. Under a program's pointer lock only the buttons pass, which also covers the time before the app sees the +lock. + +The app logs `pen route -> (mode=)` and the compositor `[pen] gets the pen as the +pointer`. + +## Limits + +- A hardware eraser end clicks like the tip. +- The pen and a mouse share the pointer's buttons, so a release from one ends a press of the other, as with the + touch fallback. +- Some systems keep the pen's button for themselves, such as Samsung's Air actions. ColorOS opens its stylus + palette for the OPPO AI Pen's key unless that action is turned off in the system's stylus settings. diff --git a/docs/development/phantom-processes.md b/docs/development/phantom-processes.md new file mode 100644 index 0000000000..bf66c9af29 --- /dev/null +++ b/docs/development/phantom-processes.md @@ -0,0 +1,193 @@ +# Android's child-process limit and the guest session + +Since Android 12 the platform counts the processes an app forks as "phantom processes" and +kills them under pressure. A Wine, FEX or Steam session forks dozens of them, so this limit +decides whether a session survives. This note records how the platform counts, what it kills, +why the guest cannot leave the count, and what DroidDeck changes on the device. + +## What the platform counts + +Discovery is a cgroup scan, not a parent-child relation. For every app process the platform +knows, it reads the cgroup member list of that process and takes every pid that is not a known +app process as a phantom of it: + +- `frameworks/base/services/core/java/com/android/server/am/PhantomProcessList.java:117-122` + holds the two cgroup roots (`/acct/uid_` for cgroup v1, `/sys/fs/cgroup/uid_` for v2) and + the `cgroup.procs` file name. +- `PhantomProcessList.java:136-208` scans every app process; `:220-222` builds the path + `/…/uid_/pid_/cgroup.procs`; `:238-275` turns a pid that is not a known app + process into a phantom of that app process. +- The mechanism is the same in Android 12.0, 12.1, 13, 14, 15, 16 and in `main`. Only the + path lookup moved to a native helper in 16 and `main` + (`PhantomProcessList.java:205`). + +DroidDeck's guest is forked by the main app process: `SessionService` starts it with +`HostProcess.start` (`app/src/main/java/com/droiddeck/launcher/session/SessionService.kt:779`), +and both `SessionService` and `SessionActivity` run in the main process +(`app/src/main/AndroidManifest.xml:284-293`, `:326-329`). Every guest process is therefore a +phantom of the main app process. + +## What the platform kills + +1. Count trim. When the number of phantom processes in the system passes + `MAX_PHANTOM_PROCESSES` (32 by default, `ActivityManagerConstants.java:192`), the surplus + is killed, starting with the phantoms whose parent app has the least importance + (`PhantomProcessList.java:423-466`). +2. Excessive CPU group kill. Every five minutes the platform measures each app's CPU use. For + an app whose process state is HOME or less important (backgrounded), a phantom process that + used more than its threshold (25, 25, 10 or 2 percent) is killed together with its phantom + siblings **and the app process itself** + (`ActivityManagerService.java:16114-16152`, `PhantomProcessList.java:496-515`). A + foreground DroidDeck is exempt; a backgrounded one is not. + +The second path is the one that ends a session without an error message in the guest log: the +app process dies with it. + +## The gate, and how the versions differ + +Both paths are behind the feature flag `settings_enable_monitor_phantom_procs`, whose default +is on. The flag is read from `Settings.Global` first +(`frameworks/base/core/java/android/util/FeatureFlagUtils.java:68-70`, `:272-283`). When it is +off, the trim returns early (`PhantomProcessList.java:423-427`) and the phantom CPU check is +skipped (`ActivityManagerService.java:16117-16118`, `:16144-16148`). From 12L on it also stops +the periodic cgroup scan that discovers phantom processes (`AppProfiler.java:1788-1829` at +`android-12.1.0_r1`). + +| Android | flag `settings_enable_monitor_phantom_procs` | count limit | CPU group kill | +| --- | --- | --- | --- | +| 12.0 (SDK 31) | does not exist | DeviceConfig `activity_manager/max_phantom_processes`, default 32 | not gated | +| 12L (SDK 32) | exists | flag | flag | +| 13 and later (SDK 33+) | exists | flag | flag | + +The flag was added in 12.1. On 12.0 the count limit comes from DeviceConfig +(`ActivityManagerConstants.java:1202-1206` in 12.0) and the CPU group kill has no gate at all +(`ActivityManagerService.java:14237-14271` in 12.0). + +## Why the guest cannot leave the count + +- **Reparenting does not help.** A double fork, `setsid()` or an orphaning parent changes the + parent and the session, not the cgroup. Cgroup membership is inherited at fork and only a + write into another cgroup's `cgroup.procs` changes it, so the platform still finds the pid + in the app process's cgroup and still counts it. On cgroup v2 the uid group cannot take + processes while it has the per-process groups as children, so there is no unscanned group to + move into. +- **A separate `:process` service only moves the count.** The scan covers every app process the + platform knows, so the guest tree started from another service of the same app is counted + against that service. The manifest already has such services + (`app/src/main/AndroidManifest.xml:78`, `:244`, `:255`), and the guest tree is one coupled + userspace whose graphics, input and session state would not survive the split. +- **The platform's own blind spot is out of reach.** Processes forked from an app zygote are + skipped by the scan (`PhantomProcessList.java:153-155`), but `android.os.AppZygote` is + `@hide` (`frameworks/base/core/java/android/os/AppZygote.java:36-38`) and hidden API + enforcement keeps it away from apps. +- **Detaching would break the session.** The guest tree is deliberately kept under a reaper: the + processes that load the session library mark themselves as child subreapers, so that a + double-forked Xwayland is reparented inside the session instead of to init, where a vendor + kernel's orphan reaper would kill it (`tools/linuxfs/preload/subreaper.c:1-16`). A guest + tree that leaves the app's process tree leaves that arrangement with nothing to reap it. + +## What DroidDeck changes on the device + +`PhantomProcessLimit` (`app/src/main/java/com/droiddeck/launcher/core/PhantomProcessLimit.kt`) +holds the platform lever per version: the DeviceConfig count limit on SDK 31 and the flag from +SDK 32 up (`:23-37`). `WirelessAdbFix` +(`app/src/main/java/com/droiddeck/launcher/core/WirelessAdbFix.kt:219-228`) runs those shell +commands over wireless debugging when the user has no computer at hand, and the gate screen +shows the result. The names on that screen come from `strings.xml` (`phantom_title_on` +"Child-process limit is on", `phantom_instructions_fix`, `phantom_fix_toggle`). + +## The remaining gap on Android 12.0 + +On SDK 31 the count trim is covered by the DeviceConfig write, but the backgrounded CPU group +kill is not: the flag does not exist there, and the CPU thresholds live in the global string +`activity_manager_constants` (`power_check_max_cpu_1` … `power_check_max_cpu_4`), not in +DeviceConfig. In 12.0 the DeviceConfig listener reacts to `max_phantom_processes` only +(`ActivityManagerConstants.java:654-757`), while the thresholds are parsed from +`Settings.Global activity_manager_constants` (`:852-892`). Raising them means rewriting that +global string, which changes the CPU kill thresholds for every app on the device. That is a +trade the developers have to accept; DroidDeck does not do it on its own. + +## Probe to run on hardware + +The mechanism above is source-verified. The probe below settles the two points a source read +cannot: what a device actually does with detached children, and whether the app uid may write +another cgroup's `cgroup.procs`. It needs a device with the guest running. + +Precondition: keep `settings_enable_monitor_phantom_procs` enabled on Android 12L (SDK 32) and +later, because disabling it also stops the cgroup scan, so no snapshot would discover either batch +(`AppProfiler.java:1788-1829` at `android-12.1.0_r1`). Android 12.0 (SDK 31) has no such flag and +scans unconditionally (`AppProfiler.java:1833-1834` at `android-12.0.0_r1`). An enabled flag, and +every 12.0 device, also keeps the backgrounded CPU group kill active, which can end the guest +together with the app process (see "What the platform kills", item 2). Keep DroidDeck in the +foreground and stop CPU-intensive guest programs before the probe. + +The limit counts phantom processes of every app on the device, not only the probe's, so raise it +before anything can trim. Record the current flag and limit values first. Then raise +`max_phantom_processes` well above any plausible device-wide count, and only after that enable the +flag if it was disabled, because a flag enabled under the default limit of 32 can trim existing +phantoms of every app at once. Wait for the platform to discover the existing phantoms, read the +device-wide phantom count, and check that the limit is above that count, plus both batches (80), +plus headroom for processes the guest and other apps start meanwhile; raise it again if not. With +the limit at its default, starting 80 long-lived processes can trigger the platform trim and +disrupt the guest session and processes of other apps. Restore the recorded values once the probe +processes have exited, in reverse order: the flag first, then the limit, because lowering the limit +schedules a trim that is skipped only while the flag is disabled. + +Run the `sleep` loops from the app's own shell so the children run under the app uid. Run each +`dumpsys activity processes` snapshot from an authorized ADB shell, because the app uid normally +cannot read that dump. After each batch, record the child PIDs and wait long enough for the +platform to discover them before taking the snapshot. + +```sh +# record the current values +adb shell settings get global settings_enable_monitor_phantom_procs +adb shell device_config get activity_manager max_phantom_processes + +# raise the limit first, then enable the flag on SDK 32 and later +adb shell device_config put activity_manager max_phantom_processes 1000 +adb shell settings put global settings_enable_monitor_phantom_procs true +# after platform discovery: device-wide phantom count +adb shell 'dumpsys activity processes | grep -i -n -A 5 phantom' + +# from the app's own shell: attached children +for i in $(seq 1 40); do sleep 600 & echo $!; done +# from an authorized ADB shell, after platform discovery +adb shell 'dumpsys activity processes | grep -i -n -A 5 phantom' + +# from the app's own shell: detached children +# (the middle process exits, so the child is reparented to init) +for i in $(seq 1 40); do ( setsid sleep 600 & echo $! ) ; done +# from an authorized ADB shell, after platform discovery +adb shell 'dumpsys activity processes | grep -i -n -A 5 phantom' + +# from the app's own shell +cat /proc//cgroup + +# whether the uid may move a child out of the scanned cgroup +echo > /sys/fs/cgroup/uid_/cgroup.procs + +# from the app's own shell: end the probe processes +kill +# restore the flag first: put the recorded value, or delete the key if it was "null" +adb shell settings put global settings_enable_monitor_phantom_procs +adb shell settings delete global settings_enable_monitor_phantom_procs +# then the limit: put the recorded value, or delete the key if it was "null" +adb shell device_config put activity_manager max_phantom_processes +adb shell device_config delete activity_manager max_phantom_processes +``` + +Compare the PIDs recorded for each batch with the phantom list in the snapshot taken after that +batch. Expected from the source: both batches are counted, the detached ones included, and the +cgroup write fails (no unscanned group, or no permission). + +## References + +- AOSP `frameworks/base`: `services/core/java/com/android/server/am/PhantomProcessList.java`, + `services/core/java/com/android/server/am/ActivityManagerService.java`, + `services/core/java/com/android/server/am/ActivityManagerConstants.java`, + `core/java/android/util/FeatureFlagUtils.java`, checked at tags android-12.0.0_r1, + android-12.1.0_r1, android-13.0.0_r1, android-14.0.0_r2, android-15.0.0_r1, + android-16.0.0_r1 and `main`. +- Pull request 1394, the OEM check of the same settings, and the issues it links, 713 and 1083. +- Termux meets the same limit on Android 12 and solves it the same way, with detection plus + the adb path (termux-app issues 4388 and 4857). diff --git a/docs/development/stores.md b/docs/development/stores.md index 278c0cbd8d..e8ff8fcbd0 100644 --- a/docs/development/stores.md +++ b/docs/development/stores.md @@ -296,7 +296,10 @@ it, the cloud copies before an upload replaces them, under A game launched before Proton has made its prefix (a first launch) gets its download deferred: the request is answered at once (`result=deferred reason=no-prefix`) and the download runs as soon as the prefix's user folder appears, within a minute. Every path logs -`cloud down|up result=ok|skipped|deferred|failed files= bytes= reason=`. +`cloud down|up result=ok|skipped|deferred|failed files= bytes= reason=`. A failure adds +`detail="..."`: the exception chain with the step (`list`, `get`, `put`), HTTP status, file and the +start of the server's error body, with URLs cut to their host and tokens, secrets and codes redacted. +GOG uploads stage their gzip body in the app's cache folder, which is created if it is missing. - **The folder:** GOG's public remote-config gives a location template per game (by its Galaxy client id), e.g. `/Hyperstrange/ELDERBORN`; Epic's catalog gives @@ -328,7 +331,10 @@ the prefix's user folder appears, within a minute. Every path logs migration runs once per game (`cloud_layout_`), so a game that legitimately keeps a folder named like the location is not relocated again; a non-prefixed listing is left unchanged. - **The services:** GOG `cloudstorage.gog.com/v1//` with a token issued to the game's - own client (the client secret is kept at install; the Galaxy token is the fallback); Epic's + own client (the client secret is kept at install; the Galaxy token is the fallback). Every + cloudstorage request sends Galaxy's communication-service `User-Agent` (`GOG_CLOUD_UA`, the + same string Heroic's gogdl and Lutris send), and PUT repeats it as `X-Object-Meta-User-Agent`; + the bare `GOG Galaxy` value is now refused with HTTP 400 `invalid_version`. Epic's savesync data storage with signed read and write links (`EpicCloud` → `EpicSaveSync` → the Rust `epic/savesync.rs`; the template's root token and `{EpicId}` / `{AppName}` are read by `EpicSaveTemplate`). diff --git a/docs/smart-glasses-support.md b/docs/smart-glasses-support.md index 0446bdb34e..123c1451c7 100644 --- a/docs/smart-glasses-support.md +++ b/docs/smart-glasses-support.md @@ -22,11 +22,11 @@ This describes the integrations implemented in DroidDeck as of 2026-10-24. A rec | **VITURE Luma Ultra** | SDK-dependent Carina transport | Yes | **Experimental, opt-in** | **Experimental, opt-in** | | Recognized RayNeo / TCL Air-series devices | Integrated RayNeo USB transport | Yes, with orientation calibration controls | No | No | | RayNeo GT-series devices matching the supported USB identity, including GT Max identification | Integrated GT USB/IMU path | Yes, with orientation calibration controls | No | No | -| **XREAL 1S** | **Experimental**; exact USB identity plus the device's USB-Ethernet control/IMU connection | Yes, when that connection is ready | No | No | +| **XREAL 1S, One, One Pro, One Pro+, Aura** | **Experimental**; exact USB identity plus the device's USB-Ethernet control/IMU connection. Head tracking and 2D/3D switching are tested on the Aura | Yes, when that connection is ready | No | No | | Rokid Max / Max 2; Rokid Air under the Max USB identity | Integrated Rokid USB transport (vendor control requests and HID IMU reports) | Yes | No | No | -| Other XREAL models; unrecognized glasses; display adapters and docks | Display-only where Android exposes a usable display; automatic glasses routing also requires display recognition | No supported app tracking connection | No | No | +| Other XREAL models (Air family and others); unrecognized glasses; display adapters and docks | Display-only where Android exposes a usable display; automatic glasses routing also requires display recognition | No supported app tracking connection | No | No | -RayNeo's Air-series recognition uses its known USB identity or a RayNeo/TCL Air name under the accepted vendor IDs; it is not a per-model certification list. The GT vendor path requires the specific supported product ID. Rokid recognition requires USB 04d2:162f (Max/Air) or 04d2:2002 (Max 2), plus a Rokid product name, since that vendor ID is shared with unrelated devices. Max 2 reports the USB product name "Rokid Max2". Hardware checks cover the Max and Max 2; the Air follows the same published protocol untested. XREAL support currently targets **1S only**: One, One Pro, Air-family devices, and recovery-mode products are not enabled by the 1S transport. VITURE Pro 2 is identified through SDK validation rather than a guessed product ID. A dock does not supply the connected glasses' sensors by itself. +RayNeo's Air-series recognition uses its known USB identity or a RayNeo/TCL Air name under the accepted vendor IDs; it is not a per-model certification list. The GT vendor path requires the specific supported product ID. Rokid recognition requires USB 04d2:162f (Max/Air) or 04d2:2002 (Max 2), plus a Rokid product name, since that vendor ID is shared with unrelated devices. Max 2 reports the USB product name "Rokid Max2". Hardware checks cover the Max and Max 2; the Air follows the same published protocol untested. XREAL support targets the 1S, One, One Pro, One Pro+ and Aura by exact USB product ID; Air-family devices and recovery-mode products are not enabled by this transport. VITURE Pro 2 is identified through SDK validation rather than a guessed product ID. A dock does not supply the connected glasses' sensors by itself. The final column refers specifically to Luma Ultra's stereo tracking cameras. DroidDeck's separate phone-camera and physical-controller features are independent of this matrix. @@ -43,6 +43,7 @@ All display modes depend on the phone's video output, the cable/adapter, and And | VITURE Pro 2 | 1080p per eye; 2D and SBS | Brightness and volume; no electrochromic-film control | | RayNeo Air/GT | 2D/SBS switching; resolution and refresh follow available Android modes | Orientation calibration; no app brightness, volume, or dimming commands | | XREAL 1S | Supported 1S display-mode commands, including native 1200p/60 Hz and SBS | Brightness and dimming toggle; no app volume command | +| XREAL One, One Pro, One Pro+, Aura | 2D and SBS only, switched with the glasses' 3D input command; the display-mode set command is never sent (an unexpected index reboots the Aura) | No app brightness, dimming or volume commands | | Rokid Max / Max 2 | 1080p at 60 or 120 Hz in 2D; SBS at 1080p/60, 1200p/60, or 1200p/90 | Brightness; volume follows Android's USB audio volume; no dimming film | | Rokid Air | 1080p/60 in 2D and SBS | Brightness; volume follows Android's USB audio volume | @@ -56,7 +57,7 @@ The pointer is left out of the picture when it cannot be drawn where the game is ## Setup and app-wide behavior -1. Connect the glasses through a compatible video/data connection. Accept USB access when requested. For XREAL 1S, Android must also expose the glasses' USB-Ethernet network; the app leaves Steam's Internet connection on its normal network. +1. Connect the glasses through a compatible video/data connection. Accept USB access when requested. For XREAL 1S, One, One Pro, One Pro+ and Aura, Android must also expose the glasses' USB-Ethernet network; the app leaves Steam's Internet connection on its normal network. 2. Open **Setup → Smart glasses**. Enable glasses output and **3DoF virtual screen**. This selects the tracked screen and saves the setting without forcing SBS or changing brightness. 3. Adjust screen width and distance, then recenter while looking where the screen should sit. The same settings apply when navigating DroidDeck, opening a non-Steam launcher, or entering a game/desktop session. 4. On an SDK-enabled Luma Ultra, optionally enable positional tracking and set the floor from the current eye height. Use the tracking setup and recovery controls for calibration or recentering. SteamVR startup defers Luma positional initialization until two seconds after SteamVR reports running. @@ -85,4 +86,4 @@ If only a flat picture is available, check video output first, then the control - [Agent diagnostics and capture commands](agent-control.md) - [RayNeo attribution and protocol references](third-party/rayneo/README.md) -The capability definitions are maintained in [VITURE models](../app/src/main/java/com/droiddeck/launcher/glasses/VitureProtocol.kt), [RayNeo models](../app/src/main/java/com/droiddeck/launcher/glasses/RayNeoModel.kt), [XREAL 1S](../app/src/main/java/com/droiddeck/launcher/glasses/XrealModel.kt), [Rokid](../app/src/main/java/com/droiddeck/launcher/glasses/RokidModel.kt), and [connection capability routing](../app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt). Update this matrix when those integrations change. +The capability definitions are maintained in [VITURE models](../app/src/main/java/com/droiddeck/launcher/glasses/VitureProtocol.kt), [RayNeo models](../app/src/main/java/com/droiddeck/launcher/glasses/RayNeoModel.kt), [XREAL](../app/src/main/java/com/droiddeck/launcher/glasses/XrealModel.kt), [Rokid](../app/src/main/java/com/droiddeck/launcher/glasses/RokidModel.kt), and [connection capability routing](../app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt). Update this matrix when those integrations change. diff --git a/settings.gradle b/settings.gradle index d614864989..6abc4f6609 100644 --- a/settings.gradle +++ b/settings.gradle @@ -15,4 +15,4 @@ dependencyResolutionManagement { } rootProject.name = "DroidDeck" -include ':app' +include ':app', ':shortcuts' diff --git a/shortcuts/build.gradle b/shortcuts/build.gradle new file mode 100644 index 0000000000..b9e37dd89d --- /dev/null +++ b/shortcuts/build.gradle @@ -0,0 +1,48 @@ +plugins { + id 'com.android.application' +} + +android { + namespace 'com.droiddeck.shortcuts' + compileSdk 34 + + defaultConfig { + applicationId 'com.droiddeck.shortcuts' + minSdkVersion 26 + targetSdkVersion 28 + versionCode 1 + versionName '1' + } + + sourceSets.main.java.srcDir('src/protocol/java') + + signingConfigs { + testkey { + storeFile file("${rootDir}/keystore/testkey.p12") + storeType 'PKCS12' + storePassword 'android' + keyAlias 'testkey' + keyPassword 'android' + enableV1Signing = true + enableV2Signing = true + enableV3Signing = true + } + } + + buildTypes { + debug { signingConfig signingConfigs.testkey } + release { + minifyEnabled false + signingConfig signingConfigs.testkey + } + } + + lint { + disable 'ExpiredTargetSdkVersion' + } + + compileOptions { + sourceCompatibility JavaVersion.VERSION_17 + targetCompatibility JavaVersion.VERSION_17 + } +} diff --git a/shortcuts/src/main/AndroidManifest.xml b/shortcuts/src/main/AndroidManifest.xml new file mode 100644 index 0000000000..2409846f7b --- /dev/null +++ b/shortcuts/src/main/AndroidManifest.xml @@ -0,0 +1,18 @@ + + + + + + + + + + + + diff --git a/shortcuts/src/main/java/com/droiddeck/shortcuts/ShortcutsService.java b/shortcuts/src/main/java/com/droiddeck/shortcuts/ShortcutsService.java new file mode 100644 index 0000000000..67410a3103 --- /dev/null +++ b/shortcuts/src/main/java/com/droiddeck/shortcuts/ShortcutsService.java @@ -0,0 +1,254 @@ +package com.droiddeck.shortcuts; + +import android.accessibilityservice.AccessibilityService; +import android.accessibilityservice.AccessibilityServiceInfo; +import android.content.BroadcastReceiver; +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.ServiceConnection; +import android.content.pm.PackageManager; +import android.content.pm.ResolveInfo; +import android.graphics.Rect; +import android.os.Build; +import android.os.Handler; +import android.os.HandlerThread; +import android.os.IBinder; +import android.os.Parcel; +import android.os.RemoteException; +import android.util.SparseArray; +import android.view.Display; +import android.view.KeyEvent; +import android.view.accessibility.AccessibilityEvent; +import android.view.accessibility.AccessibilityNodeInfo; +import android.view.accessibility.AccessibilityWindowInfo; + +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CopyOnWriteArrayList; + +public class ShortcutsService extends AccessibilityService { + private final CopyOnWriteArrayList links = new CopyOnWriteArrayList<>(); + private HandlerThread windowsThread; + private Handler windows; + private boolean watchingWindows; + private boolean receiving; + private final Runnable snapshot = this::sendWindows; + + private final BroadcastReceiver packages = new BroadcastReceiver() { + @Override public void onReceive(Context context, Intent intent) { bindAll(); } + }; + + private final class Link implements ServiceConnection { + final ComponentName component; + volatile IBinder binder; + volatile int flags; + + Link(ComponentName component) { this.component = component; } + + @Override public void onServiceConnected(ComponentName name, IBinder service) { + binder = service; + flags = config(service); + if ((flags & Relay.WANTS_WINDOWS) != 0) watchWindows(); + } + + @Override public void onServiceDisconnected(ComponentName name) { binder = null; } + + @Override public void onBindingDied(ComponentName name) { drop(this); bindAll(); } + + @Override public void onNullBinding(ComponentName name) { drop(this); } + } + + @Override + protected void onServiceConnected() { + windowsThread = new HandlerThread("shortcuts-windows"); + windowsThread.start(); + windows = new Handler(windowsThread.getLooper()); + IntentFilter filter = new IntentFilter(); + filter.addAction(Intent.ACTION_PACKAGE_ADDED); + filter.addAction(Intent.ACTION_PACKAGE_REPLACED); + filter.addDataScheme("package"); + registerReceiver(packages, filter); + receiving = true; + bindAll(); + } + + private void bindAll() { + List found = getPackageManager().queryIntentServices(new Intent(Relay.ACTION), 0); + for (ResolveInfo info : found) { + // Keys and window contents only go to a relay signed with the same key as this companion. + if (getPackageManager().checkSignatures(getPackageName(), info.serviceInfo.packageName) + != PackageManager.SIGNATURE_MATCH) continue; + ComponentName component = new ComponentName(info.serviceInfo.packageName, info.serviceInfo.name); + boolean linked = false; + for (Link link : links) if (link.component.equals(component)) linked = true; + if (linked) continue; + Link link = new Link(component); + try { + if (bindService(new Intent(Relay.ACTION).setComponent(component), link, Context.BIND_AUTO_CREATE)) links.add(link); + else unbindService(link); + } catch (RuntimeException ignored) { + } + } + } + + private void drop(Link link) { + links.remove(link); + try { unbindService(link); } catch (RuntimeException ignored) {} + } + + private static int config(IBinder binder) { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(Relay.DESCRIPTOR); + binder.transact(Relay.CONFIG, data, reply, 0); + return reply.readInt(); + } catch (RemoteException | RuntimeException e) { + return 0; + } finally { + data.recycle(); + reply.recycle(); + } + } + + private void watchWindows() { + if (Build.VERSION.SDK_INT < 30) return; + if (!watchingWindows) { + watchingWindows = true; + AccessibilityServiceInfo info = getServiceInfo(); + if (info != null) { + info.eventTypes |= AccessibilityEvent.TYPE_WINDOWS_CHANGED | AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED; + info.flags |= AccessibilityServiceInfo.FLAG_RETRIEVE_INTERACTIVE_WINDOWS; + setServiceInfo(info); + } + } + windows.removeCallbacks(snapshot); + windows.post(snapshot); + } + + @Override + protected boolean onKeyEvent(KeyEvent event) { + boolean taken = false; + for (Link link : links) { + IBinder binder = link.binder; + if (binder == null) continue; + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + try { + data.writeInterfaceToken(Relay.DESCRIPTOR); + event.writeToParcel(data, 0); + binder.transact(Relay.KEY, data, reply, 0); + if (reply.readInt() != 0) taken = true; + } catch (RemoteException | RuntimeException ignored) { + } finally { + data.recycle(); + reply.recycle(); + } + } + return taken; + } + + @Override + public void onAccessibilityEvent(AccessibilityEvent event) { + if (!watchingWindows || event == null || Build.VERSION.SDK_INT < 30) return; + int type = event.getEventType(); + if (type == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) { + CharSequence pkg = event.getPackageName(); + int display = event.getDisplayId(); + if (pkg == null || display == Display.DEFAULT_DISPLAY) return; + String name = pkg.toString(); + long at = event.getEventTime(); + sendAll(Relay.ARRIVAL, data -> { + data.writeInt(display); + data.writeString(name); + data.writeLong(at); + }); + } else if (type != AccessibilityEvent.TYPE_WINDOWS_CHANGED) { + return; + } + windows.removeCallbacks(snapshot); + windows.postDelayed(snapshot, 150); + } + + private void sendWindows() { + if (Build.VERSION.SDK_INT < 30) return; + SparseArray> all; + try { all = getWindowsOnAllDisplays(); } catch (RuntimeException e) { return; } + Map> displays = new LinkedHashMap<>(); + for (int i = 0; i < all.size(); i++) { + if (all.keyAt(i) == Display.DEFAULT_DISPLAY) continue; + List windows = new ArrayList<>(); + for (AccessibilityWindowInfo window : all.valueAt(i)) { + Rect bounds = new Rect(); + window.getBoundsInScreen(bounds); + windows.add(new Relay.Window(window.getId(), window.getType(), window.getLayer(), bounds, packageOf(window))); + } + displays.put(all.keyAt(i), windows); + } + byte[] bytes = Relay.encode(displays); + sendAll(Relay.WINDOWS, data -> data.writeByteArray(bytes)); + } + + private static String packageOf(AccessibilityWindowInfo window) { + try { + AccessibilityNodeInfo root = window.getRoot(); + if (root == null || root.getPackageName() == null) return null; + return root.getPackageName().toString(); + } catch (RuntimeException e) { + return null; + } + } + + private interface Writer { void write(Parcel data); } + + private void sendAll(int code, Writer writer) { + for (Link link : links) { + IBinder binder = link.binder; + if (binder == null) continue; + if (code != Relay.INTERRUPT && (link.flags & Relay.WANTS_WINDOWS) == 0) continue; + Parcel data = Parcel.obtain(); + try { + data.writeInterfaceToken(Relay.DESCRIPTOR); + writer.write(data); + binder.transact(code, data, null, IBinder.FLAG_ONEWAY); + } catch (RemoteException | RuntimeException ignored) { + } finally { + data.recycle(); + } + } + } + + @Override + public void onInterrupt() { + sendAll(Relay.INTERRUPT, data -> {}); + } + + @Override + public boolean onUnbind(Intent intent) { + release(); + return super.onUnbind(intent); + } + + @Override + public void onDestroy() { + release(); + super.onDestroy(); + } + + private void release() { + if (receiving) { + receiving = false; + try { unregisterReceiver(packages); } catch (RuntimeException ignored) {} + } + for (Link link : links) drop(link); + if (windowsThread != null) { + windows.removeCallbacksAndMessages(null); + windowsThread.quitSafely(); + windowsThread = null; + } + } +} diff --git a/shortcuts/src/main/res/values/strings.xml b/shortcuts/src/main/res/values/strings.xml new file mode 100644 index 0000000000..816e96bcf8 --- /dev/null +++ b/shortcuts/src/main/res/values/strings.xml @@ -0,0 +1,6 @@ + + + DroidDeck system keys + DroidDeck system keys + Keep Alt+Tab, the Win key and the Home button inside a focused DroidDeck session instead of Android. + diff --git a/app/src/main/res/xml/home_button_service.xml b/shortcuts/src/main/res/xml/shortcuts_service.xml similarity index 80% rename from app/src/main/res/xml/home_button_service.xml rename to shortcuts/src/main/res/xml/shortcuts_service.xml index 0c67e9effd..af91baa315 100644 --- a/app/src/main/res/xml/home_button_service.xml +++ b/shortcuts/src/main/res/xml/shortcuts_service.xml @@ -4,4 +4,4 @@ android:accessibilityFlags="flagRequestFilterKeyEvents" android:canRequestFilterKeyEvents="true" android:canRetrieveWindowContent="true" - android:description="@string/integration_shortcuts_service_description" /> + android:description="@string/service_description" /> diff --git a/shortcuts/src/protocol/java/com/droiddeck/shortcuts/Relay.java b/shortcuts/src/protocol/java/com/droiddeck/shortcuts/Relay.java new file mode 100644 index 0000000000..77f354d055 --- /dev/null +++ b/shortcuts/src/protocol/java/com/droiddeck/shortcuts/Relay.java @@ -0,0 +1,90 @@ +package com.droiddeck.shortcuts; + +import android.graphics.Rect; +import android.os.Parcel; + +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +public final class Relay { + public static final String PACKAGE = "com.droiddeck.shortcuts"; + public static final String SERVICE = PACKAGE + ".ShortcutsService"; + public static final String ACTION = "com.droiddeck.shortcuts.RELAY"; + public static final String DESCRIPTOR = "com.droiddeck.shortcuts.Relay"; + + public static final int CONFIG = 1; + public static final int KEY = 2; + public static final int INTERRUPT = 3; + public static final int ARRIVAL = 4; + public static final int WINDOWS = 5; + + public static final int WANTS_WINDOWS = 1; + + public static final class Window { + public final int id; + public final int type; + public final int layer; + public final Rect bounds; + public final String pkg; + + public Window(int id, int type, int layer, Rect bounds, String pkg) { + this.id = id; + this.type = type; + this.layer = layer; + this.bounds = bounds; + this.pkg = pkg; + } + } + + public static byte[] encode(Map> displays) { + Parcel parcel = Parcel.obtain(); + try { + parcel.writeInt(displays.size()); + for (Map.Entry> display : displays.entrySet()) { + parcel.writeInt(display.getKey()); + parcel.writeInt(display.getValue().size()); + for (Window window : display.getValue()) { + parcel.writeInt(window.id); + parcel.writeInt(window.type); + parcel.writeInt(window.layer); + parcel.writeInt(window.bounds.left); + parcel.writeInt(window.bounds.top); + parcel.writeInt(window.bounds.right); + parcel.writeInt(window.bounds.bottom); + parcel.writeString(window.pkg); + } + } + return parcel.marshall(); + } finally { + parcel.recycle(); + } + } + + public static Map> decode(byte[] bytes) { + Parcel parcel = Parcel.obtain(); + try { + parcel.unmarshall(bytes, 0, bytes.length); + parcel.setDataPosition(0); + Map> displays = new LinkedHashMap<>(); + for (int d = parcel.readInt(); d > 0; d--) { + int display = parcel.readInt(); + List windows = new ArrayList<>(); + for (int w = parcel.readInt(); w > 0; w--) { + int id = parcel.readInt(); + int type = parcel.readInt(); + int layer = parcel.readInt(); + Rect bounds = new Rect(parcel.readInt(), parcel.readInt(), parcel.readInt(), parcel.readInt()); + windows.add(new Window(id, type, layer, bounds, parcel.readString())); + } + displays.put(display, windows); + } + return displays; + } finally { + parcel.recycle(); + } + } + + private Relay() {} +} diff --git a/tools/agent/dd-lab-build b/tools/agent/dd-lab-build index b29c6bc5a6..4f5671dc04 100755 --- a/tools/agent/dd-lab-build +++ b/tools/agent/dd-lab-build @@ -113,11 +113,10 @@ if [ ! -d "$ANDROID_HOME/platforms/android-34" ]; then "$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager" "platforms;android-34" "build-tools;35.0.0" >/dev/null fi -# A full Kotlin compile of the app needs about 2.5 GB of heap and Gradle about 1 GB; smaller devices get -# what they can spare. Both daemons end with this script's process when the build is done. -total_mb=$(awk '/^MemTotal:/ {print int($2 / 1024)}' /proc/meminfo) -heap=$(( total_mb / 2 )); [ $heap -gt 4096 ] && heap=4096; [ $heap -lt 2048 ] && heap=2048 -heap=${DD_LAB_HEAP_MB:-$heap} +# A full Kotlin compile of the app runs out of memory with 2.4 GB of heap, and Gradle needs about 1 GB, +# so devices with less memory to spare swap rather than fail. Both daemons end with this script's +# process when the build is done. +heap=${DD_LAB_HEAP_MB:-4096} kotlin_heap=$(( heap * 2 / 3 )); gradle_heap=$(( heap - kotlin_heap )) # Only the Kotlin daemon compiles incrementally; in-process compiles always redo the whole app, and the diff --git a/tools/directaudio/sink/module-directaudio-native-sink.c b/tools/directaudio/sink/module-directaudio-native-sink.c index 3311fe0ed7..a9daf783de 100644 --- a/tools/directaudio/sink/module-directaudio-native-sink.c +++ b/tools/directaudio/sink/module-directaudio-native-sink.c @@ -65,6 +65,7 @@ PA_MODULE_USAGE( #define DA_RING_CAP_MS_LOCAL 250 #define DA_FREEZE_GAP_NS 500000000ull #define DA_CB_STALL_NS 1000000000ull +#define DA_HOST_RESTART_STALLS 3 #define DA_DECAY_QUIET_NS 10000000000ull #define DA_DECAY_PUNISH_NS 5000000000ull #define DA_DECAY_MAX_BACKOFF 32 @@ -106,6 +107,7 @@ struct userdata { uint64_t last_cb_ns, last_xrun_ns, last_decay_ns, wd_last_tick_ns; int32_t base_buf_frames, decay_floor; unsigned int decay_backoff, cb_count, wd_last_cb; + uint64_t stall_state; int reopen_running, reopen_redo; int consuming, primed, starved; int suspended; @@ -154,6 +156,13 @@ static void limit(float *p, uint32_t samples) { } } +static void record_callback(struct userdata *u) { + uint64_t state = __atomic_load_n(&u->stall_state, __ATOMIC_SEQ_CST); + + while (!__atomic_compare_exchange_n(&u->stall_state, &state, + ((state >> 32) + 1) << 32, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {} +} + static aaudio_data_callback_result_t out_cb(AAudioStream *aq, void *user, void *audioData, int32_t numFrames) { struct userdata *u = user; struct da_ring *r = u->ring; @@ -170,6 +179,8 @@ static aaudio_data_callback_result_t out_cb(AAudioStream *aq, void *user, void * return AAUDIO_CALLBACK_RESULT_CONTINUE; } + record_callback(u); + ridx = __atomic_load_n(&r->ridx, __ATOMIC_ACQUIRE); avail = __atomic_load_n(&r->widx, __ATOMIC_ACQUIRE) - ridx; if (!u->primed) { @@ -412,10 +423,12 @@ static void request_reopen(struct userdata *u, const char *why) { static void watchdog(struct userdata *u) { uint64_t now = now_ns(), last_cb, prev_tick; unsigned int cb; + uint64_t stalled; if (!u->watchdog_on) return; if (!__atomic_load_n(&u->aq, __ATOMIC_SEQ_CST)) return; + stalled = __atomic_load_n(&u->stall_state, __ATOMIC_SEQ_CST); prev_tick = u->wd_last_tick_ns; u->wd_last_tick_ns = now; cb = __atomic_load_n(&u->cb_count, __ATOMIC_SEQ_CST); @@ -431,6 +444,13 @@ static void watchdog(struct userdata *u) { if (!last_cb || now - last_cb < DA_CB_STALL_NS) return; __atomic_store_n(&u->last_cb_ns, now, __ATOMIC_SEQ_CST); + if (__atomic_load_n(&u->cb_count, __ATOMIC_SEQ_CST) != cb) return; + if (!__atomic_compare_exchange_n(&u->stall_state, &stalled, stalled + 1, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) return; + if ((uint32_t) (stalled + 1) >= DA_HOST_RESTART_STALLS) { + pa_log("directaudio-native-sink: no data callback after %u stream recoveries; restarting the audio host", (unsigned int) (stalled + 1)); + _exit(EXIT_FAILURE); + return; + } request_reopen(u, "data callback stalled"); } diff --git a/tools/droiddeckctl b/tools/droiddeckctl index ea82343888..2ade313d41 100755 --- a/tools/droiddeckctl +++ b/tools/droiddeckctl @@ -67,10 +67,11 @@ def adb_path(configured: str | None) -> str: raise ControlError("adb not found; set ADB, ANDROID_HOME, or ANDROID_SDK_ROOT", "ADB_NOT_FOUND") -def run_adb(adb: str, serial: str, *args: str, timeout: float = 30) -> subprocess.CompletedProcess[bytes]: +def run_adb(adb: str, serial: str, *args: str, timeout: float = 30, + stdin: bytes | None = None) -> subprocess.CompletedProcess[bytes]: try: return subprocess.run( - [adb, "-s", serial, *args], capture_output=True, check=False, timeout=timeout + [adb, "-s", serial, *args], input=stdin, capture_output=True, check=False, timeout=timeout ) except (OSError, subprocess.TimeoutExpired) as exc: raise ControlError(str(exc), "ADB_FAILED") from exc @@ -287,7 +288,9 @@ def displays(adb: str, serial: str) -> list[dict]: def physical_display(adb: str, serial: str, logical: int | None) -> str | None: if logical is None: - return None + found = displays(adb, serial) + main = next((d["physicalId"] for d in found if d["display"] == 0), None) + return main if len(found) > 1 else None for d in displays(adb, serial): if d["display"] == logical: if not d["physicalId"]: @@ -596,6 +599,199 @@ def input_request(args: argparse.Namespace) -> dict: raise ControlError(f"Unknown input type {kind}", "INVALID_INPUT") +PEN_MAX_MS = 30_000 +UINPUT_SCALE = 16 +UINPUT_PRESSURE = 4095 +UINPUT_DISTANCE = 255 +UINPUT_REGISTER_MS = 1000 +UINPUT_TAIL_MS = 300 +UINPUT_SYNC = "droiddeckctl-pen-done" + + +def pen_span(value: str) -> tuple[float, float]: + try: + low, high = map(float, value.split(":")) if ":" in value else (float(value),) * 2 + except ValueError: + raise argparse.ArgumentTypeError(f"{value!r} is not a number or FROM:TO") from None + return low, high + + +def pen_times(start: float, duration: float, rate: float) -> list[float]: + steps = max(1, round(duration * rate / 1000)) + return [start + duration * i / steps for i in range(steps + 1)] + + +def pen_lerp(span: tuple[float, float], fraction: float) -> float: + return span[0] + (span[1] - span[0]) * fraction + + +def pen_samples(args: argparse.Namespace) -> list[dict]: + op = args.pen_op + contact = op in ("tap", "stroke") + side = args.button if op == "button" else None + lead = 0 if op == "hover" else args.hover_ms + length = args.duration if op in ("hover", "stroke") else args.hold + total = 2 * lead + length + start = end = (args.x, args.y) + if op == "stroke": + end = (args.x2, args.y2) + elif op == "hover" and args.to: + end = tuple(args.to) + for name in ("duration", "hold", "hover_ms"): + if getattr(args, name, 0) < 0: + raise ControlError(f"--{name.replace('_', '-')} must not be negative", "INVALID_INPUT") + if not 1 <= args.rate <= 1000: + raise ControlError("--rate must be 1..1000 Hz", "INVALID_INPUT") + if total > PEN_MAX_MS: + raise ControlError(f"The gesture lasts {total} ms, more than {PEN_MAX_MS}", "INVALID_INPUT") + if not all(0 <= v <= 1 for v in start + end): + raise ControlError("Positions are fractions of the screen, 0..1", "INVALID_INPUT") + if contact and not all(0 <= p <= 1 for p in args.pressure): + raise ControlError("--pressure must be 0..1", "INVALID_INPUT") + if not all(-90 <= a <= 90 for a in args.tilt_x + args.tilt_y): + raise ControlError("--tilt-x and --tilt-y must be -90..90", "INVALID_INPUT") + if not 0 <= args.distance <= UINPUT_DISTANCE: + raise ControlError(f"--distance must be 0..{UINPUT_DISTANCE}", "INVALID_INPUT") + samples = [] + + def add(t: float, phase: str, x: float, y: float, pressure: float = 0.0, button: str | None = None) -> None: + progress = t / (total or 1) + samples.append({"t": round(t), "phase": phase, "x": x, "y": y, "pressure": pressure, "button": button, + "distance": args.distance, "tilt_x": pen_lerp(args.tilt_x, progress), + "tilt_y": pen_lerp(args.tilt_y, progress)}) + + if lead: + for t in pen_times(0, lead, args.rate)[:-1]: + add(t, "hover", *start) + middle = pen_times(lead, length, args.rate) + steps = len(middle) - 1 + for i, t in enumerate(middle): + f = i / steps + x, y = pen_lerp((start[0], end[0]), f), pen_lerp((start[1], end[1]), f) + if contact: + add(t, "down" if i == 0 else "up" if i == steps else "move", x, y, pen_lerp(args.pressure, f)) + else: + add(t, "hover", x, y, button=None if i == steps else side) + if lead: + for t in pen_times(lead + length, lead, args.rate)[1:]: + add(t, "hover", *end) + add(total, "out", *end) + return samples + + +def input_viewport(dump: str) -> dict: + blocks = re.findall(r"^[ \t]*Viewports:\n((?:[ \t]+Viewport .*\n?)+)", dump, re.M) + viewports = [] + for line in re.findall(r"Viewport INTERNAL: (.*)", blocks[-1] if blocks else dump): + fields = dict(re.findall(r"(\w+)=(\[[^\]]*\]|[^,\s]+)", line)) + size = re.fullmatch(r"\[(\d+), (\d+)\]", fields.get("deviceSize", "")) + frame = re.fullmatch(r"\[(-?\d+), (-?\d+), (-?\d+), (-?\d+)\]", fields.get("physicalFrame", "")) + if size and frame and re.fullmatch(r"-?\d+", fields.get("displayId", "")) and fields.get("orientation") in ("0", "1", "2", "3"): + viewports.append({"display": int(fields["displayId"]), "rotation": int(fields["orientation"]), + "size": [int(size.group(1)), int(size.group(2))], + "frame": [int(edge) for edge in frame.groups()], "active": fields.get("isActive") != "[0]"}) + if not viewports: + raise ControlError("`dumpsys input` shows no internal display viewport to map the pen to", "NO_VIEWPORT") + viewport = next((v for v in viewports if v["display"] == 0), viewports[0]) + if not viewport["active"]: + raise ControlError(f"Display {viewport['display']} is off, and Android ignores touchscreens on it; " + "wake the device first", "NO_VIEWPORT") + return viewport + + +def uinput_point(x: float, y: float, tilt_x: float, tilt_y: float, rotation: int, width: int, + height: int, frame: list[int]) -> tuple[int, int, int, int]: + left, top, right, bottom = frame + x = min(right - 1, round(left + x * (right - left))) + y = min(bottom - 1, round(top + y * (bottom - top))) + if rotation == 1: + return width - 1 - y, x, round(-tilt_y), round(tilt_x) + if rotation == 2: + return width - 1 - x, height - 1 - y, round(-tilt_x), round(-tilt_y) + if rotation == 3: + return y, height - 1 - x, round(tilt_y), round(-tilt_x) + return x, y, round(tilt_x), round(tilt_y) + + +def uinput_commands(samples: list[dict], tool: str, viewport: dict) -> list[dict]: + rotation = viewport["rotation"] + natural = viewport["size"][::-1] if rotation % 2 else viewport["size"] + width, height = (n * UINPUT_SCALE for n in natural) + bounds = [edge * UINPUT_SCALE for edge in viewport["frame"]] + last_x = max(uinput_point(f, f, 0, 0, rotation, width, height, bounds)[0] for f in (0, 1)) + tool_key = "BTN_TOOL_RUBBER" if tool == "eraser" else "BTN_TOOL_PEN" + + def axis(code: str, low: int, high: int) -> dict: + return {"code": code, "info": {"value": 0, "minimum": low, "maximum": high, "fuzz": 0, "flat": 0, "resolution": 0}} + + commands = [ + {"id": 1, "command": "register", "name": "DroidDeck agent pen", "bus": "virtual", "configuration": [ + {"type": "UI_SET_EVBIT", "data": ["EV_KEY", "EV_ABS"]}, + {"type": "UI_SET_KEYBIT", "data": ["BTN_TOOL_PEN", "BTN_TOOL_RUBBER", "BTN_TOUCH", "BTN_STYLUS", "BTN_STYLUS2"]}, + {"type": "UI_SET_ABSBIT", "data": ["ABS_X", "ABS_Y", "ABS_PRESSURE", "ABS_DISTANCE", "ABS_TILT_X", "ABS_TILT_Y"]}, + {"type": "UI_SET_PROPBIT", "data": ["INPUT_PROP_DIRECT"]}, + ], "abs_info": [axis("ABS_X", 0, width - 1), axis("ABS_Y", 0, height - 1), axis("ABS_PRESSURE", 0, UINPUT_PRESSURE), + axis("ABS_DISTANCE", 0, UINPUT_DISTANCE), axis("ABS_TILT_X", -90, 90), axis("ABS_TILT_Y", -90, 90)]}, + {"id": 1, "command": "delay", "duration": UINPUT_REGISTER_MS}, + ] + sent = {tool_key: 0, "BTN_TOUCH": 0, "BTN_STYLUS": 0, "BTN_STYLUS2": 0} + + def frame(sample: dict, phase: str) -> list: + near, contact = phase != "out", phase in ("down", "move") + values = {tool_key: int(near), "BTN_TOUCH": int(contact), "BTN_STYLUS": int(sample["button"] == "primary"), + "BTN_STYLUS2": int(sample["button"] == "secondary")} + if near: + x, y, tilt_x, tilt_y = uinput_point(sample["x"], sample["y"], sample["tilt_x"], sample["tilt_y"], + rotation, width, height, bounds) + values.update(ABS_X=x, ABS_Y=y, ABS_PRESSURE=max(1, round(sample["pressure"] * UINPUT_PRESSURE)) if contact else 0, + ABS_DISTANCE=0 if contact else sample["distance"], ABS_TILT_X=tilt_x, ABS_TILT_Y=tilt_y) + events = [] + for code, value in values.items(): + if sent.get(code) != value: + events += ["EV_KEY" if code.startswith("BTN_") else "EV_ABS", code, value] + sent[code] = value + return events + ["EV_SYN", "SYN_REPORT", 0] if events else [] + + now = 0 + for sample in samples: + events = frame(sample, "move") if sample["phase"] == "up" else [] + events += frame(sample, sample["phase"]) + if not events: + sent["ABS_X"] += 1 if sent["ABS_X"] < last_x else -1 + events = ["EV_ABS", "ABS_X", sent["ABS_X"], "EV_SYN", "SYN_REPORT", 0] + if sample["t"] > now: + commands.append({"id": 1, "command": "delay", "duration": sample["t"] - now}) + now = sample["t"] + commands.append({"id": 1, "command": "inject", "events": events}) + return commands + [{"id": 1, "command": "delay", "duration": UINPUT_TAIL_MS}, + {"id": 1, "command": "sync", "syncToken": UINPUT_SYNC}] + + +def pen_uinput(adb: str, serial: str, samples: list[dict], tool: str) -> dict: + probe = run_adb(adb, serial, "shell", + "command -v uinput >/dev/null 2>&1 || echo no-uinput; [ -w /dev/uinput ] || echo no-dev-uinput") + if probe.returncode != 0: + raise ControlError((probe.stdout + probe.stderr).decode(errors="replace").strip() or "adb shell failed", "ADB_FAILED") + missing = probe.stdout.decode(errors="replace").split() + if "no-uinput" in missing: + raise ControlError("This device's shell has no `uinput` command", "UINPUT_UNAVAILABLE") + if "no-dev-uinput" in missing: + raise ControlError("The ADB shell cannot write /dev/uinput on this device", "UINPUT_UNAVAILABLE") + viewport = input_viewport(run_adb(adb, serial, "shell", "dumpsys", "input").stdout.decode(errors="replace")) + script = "".join(json.dumps(command) + "\n" for command in uinput_commands(samples, tool, viewport)) + started = time.monotonic() + result = run_adb(adb, serial, "shell", "uinput", "-", stdin=script.encode(), + timeout=(UINPUT_REGISTER_MS + samples[-1]["t"] + UINPUT_TAIL_MS) / 1000 + 30) + elapsed = round((time.monotonic() - started) * 1000) + if UINPUT_SYNC not in result.stdout.decode(errors="replace"): + detail = (result.stderr or result.stdout).decode(errors="replace").strip()[-400:] + raise ControlError(f"uinput stopped before the end of the gesture (exit {result.returncode})" + + (f": {detail}" if detail else "") + "; `adb logcat -s UINPUT UinputDevice` tells why", + "UINPUT_FAILED") + return {"ok": True, "command": "input", "type": "pen", "samples": len(samples), "ms": elapsed, + "viewport": {key: viewport[key] for key in ("display", "rotation", "size")}} + + def xr_ppm_to_png(data: bytes, linear: bool = False) -> bytes: header = re.match(rb"P6\n([0-9]+) ([0-9]+)\n255\n", data) if not header: @@ -824,6 +1020,8 @@ def execute(args: argparse.Namespace, adb: str, serial: str) -> dict: "CDP_FAILED"), serial) if command == "input": + if args.input_type == "pen": + return add_serial(pen_uinput(adb, serial, pen_samples(args), args.tool), serial) return add_serial(checked(provider_call(adb, serial, "input", request=input_request(args), timeout=60), "INPUT_FAILED"), serial) @@ -1095,6 +1293,36 @@ def build_parser() -> argparse.ArgumentParser: trigger.add_argument("trigger", choices=["left", "right"]) trigger.add_argument("value", type=float, nargs="?", default=1.0) trigger.add_argument("--hold", type=int, default=200) + pen = kinds.add_parser("pen", help="a virtual pen at fractions of the screen as shown") + pen_ops = pen.add_subparsers(dest="pen_op", required=True) + pen_hover = pen_ops.add_parser("hover", help="come near at X Y, glide to --to X2 Y2 and leave") + pen_hover.add_argument("x", type=float) + pen_hover.add_argument("y", type=float) + pen_hover.add_argument("--to", type=float, nargs=2, metavar=("X2", "Y2")) + pen_hover.add_argument("--duration", type=int, default=300) + pen_tap = pen_ops.add_parser("tap", help="hover, touch down at X Y, lift and leave") + pen_tap.add_argument("x", type=float) + pen_tap.add_argument("y", type=float) + pen_tap.add_argument("--hold", type=int, default=60, help="ms in contact") + pen_stroke = pen_ops.add_parser("stroke", help="hover, draw a line from X Y to X2 Y2 and leave") + for name in ("x", "y", "x2", "y2"): + pen_stroke.add_argument(name, type=float) + pen_stroke.add_argument("--duration", type=int, default=300, help="ms in contact") + pen_button = pen_ops.add_parser("button", help="press and release a side button while hovering at X Y") + pen_button.add_argument("button", choices=["primary", "secondary"]) + pen_button.add_argument("x", type=float) + pen_button.add_argument("y", type=float) + pen_button.add_argument("--hold", type=int, default=120, help="ms the button is down") + for op in (pen_tap, pen_stroke): + op.add_argument("--pressure", type=pen_span, default=(0.5, 0.5), metavar="P[:P]") + for op in (pen_tap, pen_stroke, pen_button): + op.add_argument("--hover-ms", type=int, default=80, help="ms of hover before and after") + for op in (pen_hover, pen_tap, pen_stroke, pen_button): + op.add_argument("--tool", choices=["pen", "eraser"], default="pen") + op.add_argument("--tilt-x", type=pen_span, default=(0.0, 0.0), metavar="DEG[:DEG]") + op.add_argument("--tilt-y", type=pen_span, default=(0.0, 0.0), metavar="DEG[:DEG]") + op.add_argument("--distance", type=int, default=0, help="while hovering, in device units 0..255") + op.add_argument("--rate", type=float, default=120, help="samples per second") ui = commands.add_parser("ui", help="the app's own UI: dump nodes, click or type by test tag") ui_ops = ui.add_subparsers(dest="ui_op", required=True) @@ -1197,7 +1425,7 @@ def build_parser() -> argparse.ArgumentParser: return parser -EXIT_ADB = {"ADB_NOT_FOUND", "ADB_FAILED", "INVALID_PROVIDER_RESPONSE"} +EXIT_ADB = {"ADB_NOT_FOUND", "ADB_FAILED", "INVALID_PROVIDER_RESPONSE", "UINPUT_UNAVAILABLE", "NO_VIEWPORT", "UINPUT_FAILED"} EXIT_SESSION = { "SESSION_ACTIVE", "NO_ACTIVE_SESSION", "SESSION_NOT_SUSPENDED", "SESSION_FAILED", "GUEST_EXIT", "GUEST_START_FAILED", "RUNTIME_INSTALL_FAILED", "DESKTOP_INSTALL_FAILED", "ACTIVITY_START_FAILED", diff --git a/tools/gamescope/PATCHES.md b/tools/gamescope/PATCHES.md index 8608d7c260..953bab4a0c 100644 --- a/tools/gamescope/PATCHES.md +++ b/tools/gamescope/PATCHES.md @@ -350,3 +350,11 @@ motion while the seat is locked) with how the X pointer moves. A hinted constrai after 30 moving frames on which the X pointer follows. Any constraint goes relative once the X pointer moves less than a quarter of that motion on three frames within half a second, as it does when the game recentres it or clips it to a small rectangle (PEAK). `tools/tests/test_gamescope_pointer_hold.py` compiles the rule from this patch. + +## 0134 wlserver: a touch presses the emulated click button only once + +In the Left, Right and Middle touch click modes every finger pressed the button, but a finger lifting releases it once +and clears the held flag. wlroots counts repeated presses of one button and sends the release only when the count +reaches zero, so a second finger touching before the first lifted left the button pressed in the seat for good: the +game saw a held click, and later taps only raised and lowered the count. A finger now presses the button only when no +earlier finger holds it. `tools/tests/test_gamescope_touch_click.py` compiles the rule from this patch. diff --git a/tools/gamescope/patches/0134-touch-click-press-once.patch b/tools/gamescope/patches/0134-touch-click-press-once.patch new file mode 100644 index 0000000000..3d4deaa13c --- /dev/null +++ b/tools/gamescope/patches/0134-touch-click-press-once.patch @@ -0,0 +1,33 @@ +diff --git a/src/wlserver.cpp b/src/wlserver.cpp +index d932df4..df352b0 100644 +--- a/src/wlserver.cpp ++++ b/src/wlserver.cpp +@@ -3343,6 +3343,14 @@ void wlserver_touchmotion( double x, double y, int touch_id, uint32_t time, bool + bump_input_counter(); + } + ++static bool touch_click_press( bool *pHeld, int nMode, uint32_t uButton ) ++{ ++ if ( uButton == 0 || nMode < 0 || nMode >= WLSERVER_BUTTON_COUNT || pHeld[ nMode ] ) ++ return false; ++ pHeld[ nMode ] = true; ++ return true; ++} ++ + void wlserver_touchdown( double x, double y, int touch_id, uint32_t time, gamescope::IBackendConnector* connector ) + { + assert( wlserver_is_lock_held() ); +@@ -3389,12 +3397,10 @@ void wlserver_touchdown( double x, double y, int touch_id, uint32_t time, gamesc + + uint32_t button = TouchClickModeToLinuxButton( eMode ); + +- if ( button != 0 && eMode < WLSERVER_BUTTON_COUNT ) ++ if ( touch_click_press( wlserver.button_held, eMode, button ) ) + { + wlr_seat_pointer_notify_button( wlserver.wlr.seat, time, button, WL_POINTER_BUTTON_STATE_PRESSED ); + wlr_seat_pointer_notify_frame( wlserver.wlr.seat ); +- +- wlserver.button_held[ eMode ] = true; + } + } + } diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-battlenet b/tools/linuxfs/overlay/usr/local/bin/droiddeck-battlenet index b43bd25a6f..313dc57f57 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-battlenet +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-battlenet @@ -5,6 +5,7 @@ import json import math import os import re +import runpy import shutil import signal import subprocess @@ -16,6 +17,7 @@ import urllib.request HOME = os.environ.get("HOME") or "/root" BIN = "/usr/local/bin" PROTON_RUN = os.path.join(BIN, "droiddeck-proton-run") +GAME_DEBUG = runpy.run_path(os.path.join(os.path.dirname(os.path.abspath(__file__)), "droiddeck-game-debug")) APP_ID = "2596113170" INSTALLER_URL = "https://downloader.battle.net/download/getInstallerForGame?os=win&gameProgram=BATTLENET_APP&version=Live" CLIENT_DIR = ("Program Files (x86)", "Battle.net") @@ -685,6 +687,7 @@ def steam_running(proc="/proc"): def proton_env(): env = dict(os.environ) + env = GAME_DEBUG["apply_game_debug_logs"](env) if not steam_running(): env.setdefault("PROTON_SPOOF_STEAMINPUT_VIDPID", "1") return env diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-epic b/tools/linuxfs/overlay/usr/local/bin/droiddeck-epic index 34dea7de31..d0ad7010c2 100644 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-epic +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-epic @@ -24,6 +24,7 @@ import urllib.request HOME = os.environ.get("HOME") or "/root" SELF = os.path.abspath(__file__) BIN_DIR = os.path.dirname(SELF) +GAME_DEBUG = runpy.run_path(os.path.join(BIN_DIR, "droiddeck-game-debug")) STATE = os.path.join(HOME, ".local", "share", "droiddeck-epic") CURRENT = os.path.join(STATE, "current.json") APPS = os.path.join(STATE, "app") @@ -1196,6 +1197,7 @@ def run_game(request, session_env, running=None): exe = native_path(request.get("exe") or "") args = request.get("args") or [] env = {k: v for k, v in session_env.items() if not k.startswith(("FEX_", "DROIDDECK_EPIC", "EGL_", "WEBKIT_"))} + env = GAME_DEBUG["apply_game_debug_logs"](env) preload = env.pop(STEAM_PRELOAD, "") if preload: env["LD_PRELOAD"] = preload diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex b/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex index 752ce1bdff..742cabc91a 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex @@ -8,6 +8,7 @@ import os import re import runpy import shutil +import stat import struct import subprocess import sys @@ -37,7 +38,9 @@ RUNTIMES = {SNIPER_APPID: ("sniper_platform_", "Steam Linux Runtime 3.0 (sniper" SLR4_APPID: ("steamrt4_platform_", "Steam Linux Runtime 4.0 (steamrt4")} MARKER = ".droiddeck-fex" LAYOUT = 1 -ROOTFS_LAYOUT = 9 +ROOTFS_LAYOUT = 10 +BLOB_DIRS = re.compile(r"^(?:\.ref|[0-9a-f]{2})$") +ROOTFS_LIBRARY_DIRS = ("lib", "lib64") ARCH_DIRS = ("x86_64-linux-gnu", "i386-linux-gnu") INTERPRETERS = ("ld-linux-x86-64.so.2", "ld-linux.so.2") PROVIDED = frozenset(( @@ -318,11 +321,40 @@ def provides_newer(base, provider): return True -def mirror(source, provider, name, target): +def clone(source, target, parents=()): + real = os.path.realpath(source) + if real in parents or not os.path.lexists(real): + return + if os.path.isdir(real): + os.makedirs(target, exist_ok=True) + for entry in os.listdir(real): + clone(os.path.join(real, entry), os.path.join(target, entry), parents + (real,)) + shutil.copystat(real, target) + return + shutil.copy2(real, target) + + +def remove_tree(path): + if os.path.islink(path) or not os.path.isdir(path): + with contextlib.suppress(FileNotFoundError): + os.unlink(path) + return + os.chmod(path, os.lstat(path).st_mode | stat.S_IRWXU) + for entry in os.listdir(path): + remove_tree(os.path.join(path, entry)) + os.rmdir(path) + + +def stays_in_libraries(root, target, link): + resolved = os.path.normpath(os.path.join(os.path.relpath(target, root), link)) + return resolved.split(os.sep)[0] in ROOTFS_LIBRARY_DIRS + + +def mirror(source, provider, name, target, root): usable_provider = provider and all(os.path.exists(os.path.join(provider, needed)) for needed in (name,) + PROVIDED_NEEDS.get(name, ())) if name in PROVIDED and usable_provider: - os.symlink(os.path.realpath(os.path.join(provider, name)), os.path.join(target, name)) + clone(os.path.join(provider, name), os.path.join(target, name)) return path = os.path.join(source, name) if not os.path.lexists(path): @@ -334,10 +366,10 @@ def mirror(source, provider, name, target): link = os.path.join(os.path.dirname(link), name) if provider and GLIBC_BUILD.match(name): return - if link and not link.startswith("/"): + if link and not link.startswith("/") and stays_in_libraries(root, target, link): os.symlink(link, os.path.join(target, name)) else: - os.symlink(os.path.realpath(path), os.path.join(target, name)) + clone(path, os.path.join(target, name)) def build_rootfs(base, provider): @@ -359,12 +391,12 @@ def build_rootfs(base, provider): return False for entry in os.listdir(STATE): if entry.startswith("rootfs."): - shutil.rmtree(os.path.join(STATE, entry), ignore_errors=True) + remove_tree(os.path.join(STATE, entry)) tmp = "%s.%d.tmp" % (rootfs, os.getpid()) os.makedirs(tmp) for entry in os.listdir(base_files): - if entry not in ("lib", "lib64", "usr", MARKER): - os.symlink(os.path.realpath(os.path.join(base_files, entry)), os.path.join(tmp, entry)) + if entry not in ("lib", "lib64", "usr", MARKER) and not BLOB_DIRS.match(entry): + clone(os.path.join(base_files, entry), os.path.join(tmp, entry)) os.symlink(".", os.path.join(tmp, "usr")) for top in ("lib", "lib64"): source = os.path.join(base_files, top) @@ -375,15 +407,15 @@ def build_rootfs(base, provider): provided = os.path.join(provider_files, top, entry) os.makedirs(os.path.join(tmp, top, entry)) for name in set(os.listdir(path)) | {name for name in PROVIDED if os.path.exists(os.path.join(provided, name))}: - mirror(path, provided, name, os.path.join(tmp, top, entry)) + mirror(path, provided, name, os.path.join(tmp, top, entry), tmp) else: - mirror(source, None, entry, os.path.join(tmp, top)) + mirror(source, None, entry, os.path.join(tmp, top), tmp) write_if_changed(os.path.join(tmp, MARKER), stamp) old = "%s.%d.old" % (rootfs, os.getpid()) if os.path.lexists(rootfs): os.rename(rootfs, old) os.rename(tmp, rootfs) - shutil.rmtree(old, ignore_errors=True) + remove_tree(old) return True @@ -463,7 +495,7 @@ def link_guest_sdk(root): continue os.makedirs(os.path.dirname(link), exist_ok=True) if os.path.lexists(link): - os.unlink(link) + remove_tree(link) os.symlink(directory, link) @@ -535,8 +567,6 @@ def prepare(app=SNIPER_APPID): root = os.path.join(platform, "files") if materialize(platform): say("prepared %s as the x86 runtime" % os.path.basename(platform)) - install_preloads(root) - install_fonts(root) provider = None if app == SNIPER_APPID: provider = graphics_platform() @@ -553,6 +583,8 @@ def prepare(app=SNIPER_APPID): say("built the x86 runtime from %s with the C and C++ libraries of %s" % (os.path.basename(platform), os.path.basename(provider))) root = os.path.join(STATE, "rootfs") + install_preloads(root) + install_fonts(root) with contextlib.suppress(OSError): link_guest_sdk(root) write_config(fex, root) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-debug b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-debug new file mode 100644 index 0000000000..df2e704402 --- /dev/null +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-debug @@ -0,0 +1,71 @@ +#!/usr/bin/python3 +import json +import os +import re +import sys +from pathlib import Path + +GAME_DEBUG_CHANNELS = ( + "timestamp", "pid", "tid", "seh", "unwind", "threadname", "debugstr", "loaddll", "mscoree", +) +WINE_DEBUG_SELECTOR = re.compile(r"(?:(trace|warn|err|fixme))?([+-])([A-Za-z_][A-Za-z0-9_]*)") + + +def game_debug_channels(*values): + selectors = {} + for value in values: + if not isinstance(value, str) or "\0" in value or len(value) > 8192: + continue + for part in value.split(","): + part = part.strip() + match = WINE_DEBUG_SELECTOR.fullmatch(part) + if match is None: + continue + key = (match[1] or "", match[3]) + selectors.pop(key, None) + selectors[key] = part + for channel in GAME_DEBUG_CHANNELS: + key = ("", channel) + selectors.pop(key, None) + selectors[key] = "+" + channel + formatted = ",".join(selectors.values()) + if len(formatted) > 8192: + formatted = ",".join("+" + channel for channel in GAME_DEBUG_CHANNELS) + return formatted + + +def load_config(): + try: + path = Path(os.environ.get("HOME") or "/root") / ".config/droiddeck/game-environment.json" + with path.open(encoding="utf-8") as source: + return json.load(source) + except (OSError, ValueError): + return None + + +def session_debug_dir(env): + return env.get("BL_DEBUG_DIR", "") + + +def apply_game_debug_logs(env, config=None, debug_dir=None): + if config is None: + config = load_config() + if not isinstance(config, dict) or config.get("version") != 1 or config.get("gameDebugLogs") is not True: + return env + if debug_dir is None: + debug_dir = session_debug_dir(env) + if (not isinstance(debug_dir, str) or "\0" in debug_dir or len(debug_dir) > 8192 + or not os.path.isabs(debug_dir) or not os.path.isdir(debug_dir)): + print("droiddeck-game-env: game debug logs skipped; session log directory unavailable", file=sys.stderr) + return env + result = dict(env) + result.update({ + "PROTON_LOG": "1", + "PROTON_LOG_DIR": debug_dir, + "PROTON_CRASH_REPORT_DIR": debug_dir, + "DXVK_LOG_PATH": debug_dir, + "DXVK_LOG_LEVEL": "debug", + "VKD3D_DEBUG": "info", + "WINEDEBUG": game_debug_channels(env.get("WINEDEBUG"), env.get("PROTON_LOG")), + }) + return result diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env index bbe3c868d7..ef73b33156 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-game-env @@ -17,6 +17,10 @@ D3D9_DEFAULT_MEMORY_MB = 4096 SYNC_KEYS = ("BL_SYNC", "BL_SYNC_FALLBACK", "BL_FSYNC_FIRST", "BL_SYNC_MIN_NOFILE", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC", "PROTON_NO_NTSYNC", "WINEESYNC") SEED_REDISTS = "/usr/local/bin/droiddeck-seed-redists" PACK_KEYS = ("WINESERVER", "BL_SYNC_PACK", "WINEESYNC", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC") +GAME_DEBUG = runpy.run_path(str(Path(__file__).with_name("droiddeck-game-debug"))) +game_debug_channels = GAME_DEBUG["game_debug_channels"] +apply_game_debug_logs = GAME_DEBUG["apply_game_debug_logs"] +session_debug_dir = GAME_DEBUG["session_debug_dir"] # Prefixes several games share; the game itself is the Steam app being launched. @@ -124,7 +128,8 @@ def godot_vulkan(game): @fix def godot_sentry(game): sentry = sorted(n[:-4] for n in game.files if n.startswith("libsentry.windows.") and n.endswith(".dll")) - if is_godot(game) and sentry and ("coreclr.dll" in game.files or "godotsharp.dll" in game.files): + # Sentry.Godot.dll's module initializer P/Invokes the native DLL; without it GodotPlugins fails to start. + if is_godot(game) and sentry and ("coreclr.dll" in game.files or "godotsharp.dll" in game.files) and "sentry.godot.dll" not in game.files: return {"WINEDLLOVERRIDES": ";".join(n + "=d" for n in sentry)}, [], "Godot: Sentry crash handler off" @@ -188,6 +193,21 @@ def little_nightmares_threads(game): return {"PROTONFIXES_DISABLE": "1"}, [], "Little Nightmares: umu-protonfixes off (its -onethread puts the game and renderer on one thread)" +def names_module(overrides, names): + for entry in (overrides or "").split(";"): + if "=" in entry and names & {re.sub(r"^\*|\.dll$", "", name.lower()) for name in re.split(r"[, \t]", entry.split("=", 1)[0])}: + return True + return False + + +def keyboard_helper_off(env): + if env.get("SteamDeck") == "1" or names_module(env.get("WINEDLLOVERRIDES"), {"tabtip.exe"}): + return None + own = env.get("WINEDLLOVERRIDES") + env["WINEDLLOVERRIDES"] = own + ";tabtip.exe=d" if own else "tabtip.exe=d" + return "tabtip.exe off (it only opens Steam's keyboard with SteamDeck=1, and its UI Automation calls crash games)" + + def skip_red_launcher(command): if len(command) > 2 and os.path.basename(command[2]).lower() == "redprelauncher.exe": game = os.path.join(os.path.dirname(command[2]), "bin", "x64", "Cyberpunk2077.exe") @@ -361,6 +381,36 @@ def engine_fixes(exe, args): return env, extra, notes +DS_APP_IDS = {"1190460", "1850570"} +DS_SIZE = 86479872 +DS_WINDOW_OFFSET = 0x38FE190 +DS_WINDOW = bytes.fromhex("48895c240848896c2410488974241848897c242041564883ec70458bf1498bf0488bfa488be94885c9") +DS_ORIGINAL = bytes.fromhex("0f85a5000000") +DS_FIXED = bytes.fromhex("e9a600000090") + + +def death_stranding_allocator(app_id, exe): + # The game's bundled mimalloc tries one random address between 4 and 8 TiB and never falls back, + # but a 39-bit kernel cannot map anything above 512 GiB. Jumping straight to its aligned path avoids it. + if app_id not in DS_APP_IDS or os.path.basename(exe).lower() != "ds.exe": + return False + try: + with open(exe, "r+b") as game: + if os.fstat(game.fileno()).st_size != DS_SIZE: + return False + game.seek(DS_WINDOW_OFFSET) + seen = game.read(len(DS_WINDOW) + len(DS_ORIGINAL)) + if seen[:len(DS_WINDOW)] != DS_WINDOW or seen[len(DS_WINDOW):] != DS_ORIGINAL: + return False + game.seek(DS_WINDOW_OFFSET + len(DS_WINDOW)) + game.write(DS_FIXED) + except OSError as error: + print("droiddeck-game-env: Death Stranding allocator fix not applied (%s)" % error, file=sys.stderr) + return False + print("droiddeck-game-env: Death Stranding: memory allocator no longer needs a high address (39-bit kernels)", file=sys.stderr) + return True + + def win_components(compat, app_id, proton=None, env=None): if not compat: return "" @@ -550,7 +600,16 @@ def apply_config(env, config, app_id, fixes=None): if name == "WINEDLLOVERRIDES" and entries.get(name, env.get(name)): value = entries.get(name, env.get(name)) + ";" + value entries[name] = value - entries.update(config.get("games", {}).get(app_id, {})) + game = config.get("games", {}).get(app_id, {}) + fix = (fixes or {}).get("WINEDLLOVERRIDES") + if fix and isinstance(game.get("WINEDLLOVERRIDES"), str): + own = game["WINEDLLOVERRIDES"] + combined = fix + ";" + own if own else fix + if len(combined) > 8192: + print("droiddeck-game-env: game WINEDLLOVERRIDES too long to add DroidDeck's overrides; using the game value only", file=sys.stderr) + combined = own + game = dict(game, WINEDLLOVERRIDES=combined) + entries.update(game) for name, value in entries.items(): if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", name): raise ValueError("invalid environment name") @@ -615,55 +674,6 @@ def bridge_feature_level(env): return "Mali bridge: VKD3D_FEATURE_LEVEL %s capped at 12_0 (no ray tracing or mesh shaders)" % was -GAME_DEBUG_CHANNELS = ( - "timestamp", "pid", "tid", "seh", "unwind", "threadname", "debugstr", "loaddll", "mscoree", -) -WINE_DEBUG_SELECTOR = re.compile(r"(?:(trace|warn|err|fixme))?([+-])([A-Za-z_][A-Za-z0-9_]*)") - - -def game_debug_channels(*values): - selectors = {} - for value in values: - if not isinstance(value, str) or "\0" in value or len(value) > 8192: - continue - for part in value.split(","): - part = part.strip() - match = WINE_DEBUG_SELECTOR.fullmatch(part) - if match is None: - continue - key = (match[1] or "", match[3]) - selectors.pop(key, None) - selectors[key] = part - for channel in GAME_DEBUG_CHANNELS: - key = ("", channel) - selectors.pop(key, None) - selectors[key] = "+" + channel - formatted = ",".join(selectors.values()) - if len(formatted) > 8192: - formatted = ",".join("+" + channel for channel in GAME_DEBUG_CHANNELS) - return formatted - - -def apply_game_debug_logs(env, config, debug_dir): - if not isinstance(config, dict) or config.get("version") != 1 or config.get("gameDebugLogs") is not True: - return env - if (not isinstance(debug_dir, str) or "\0" in debug_dir or len(debug_dir) > 8192 - or not os.path.isabs(debug_dir) or not os.path.isdir(debug_dir)): - print("droiddeck-game-env: game debug logs skipped; session log directory unavailable", file=sys.stderr) - return env - result = dict(env) - result.update({ - "PROTON_LOG": "1", - "PROTON_LOG_DIR": debug_dir, - "PROTON_CRASH_REPORT_DIR": debug_dir, - "DXVK_LOG_PATH": debug_dir, - "DXVK_LOG_LEVEL": "debug", - "VKD3D_DEBUG": "info", - "WINEDEBUG": game_debug_channels(env.get("WINEDEBUG"), env.get("PROTON_LOG")), - }) - return result - - def sync_config(config, app_id): games = config.get("games", {}) return { @@ -897,14 +907,11 @@ PE = runpy.run_path(str(Path(__file__).resolve().parent / "droiddeck-wine-pe")) pe_machine = PE["pe_machine"] -def repair_foreign_system_dlls(prefix, proton, env=None): +def prefix_system_dlls(prefix, proton, env=None): dist = Path(proton).parent / "files/lib/wine" windows = Path(prefix) / "pfx/drive_c/windows" machines_by_folder = PE["proton_pe_machines"](proton, env or {}) - if machines_by_folder is None: - return [] - repaired = [] - for folder, (libdir, machines) in machines_by_folder.items(): + for folder, (libdir, machines) in (machines_by_folder or {}).items(): builtins = dist / libdir try: builtin_names = {name.lower(): name for name in os.listdir(builtins)} @@ -914,35 +921,83 @@ def repair_foreign_system_dlls(prefix, proton, env=None): names = sorted(os.listdir(windows / folder)) except OSError: continue + # Both restoration and repair may examine many DLLs. Index the backup + # names from this directory listing instead of listing it for each DLL. + backups = {} + for entry in names: + stem, marker, suffix = entry.partition(FOREIGN_SUFFIX) + if not marker or not stem.lower().endswith(".dll"): + continue + if not suffix: + serial = 0 + elif suffix.startswith(".") and suffix[1:].isdigit(): + serial = int(suffix[1:]) + else: + continue + backups.setdefault(stem, []).append((serial, windows / folder / entry)) + for copies in backups.values(): + copies.sort() for name in names: - path = windows / folder / name builtin_name = builtin_names.get(name.lower()) source = builtins / builtin_name if builtin_name else builtins / name - if path.is_symlink() or not name.lower().endswith(".dll") or not source.is_file() or not path.is_file(): + if name.lower().endswith(".dll") and source.is_file(): + yield folder, name, windows / folder / name, source, machines, builtins, backups.get(name, ()) + + +def newest_foreign_backup(backups): + return backups[-1][1] if backups else None + + +def restore_compatible_system_dlls(prefix, proton, env=None): + restored = [] + for folder, name, path, source, machines, builtins, backups in prefix_system_dlls(prefix, proton, env): + if not path.is_symlink() or not path.is_file(): + continue + try: + if not os.path.samefile(path, source): continue - machine = pe_machine(path) - if machine is None or PE["machine_compatible"](path, machines, machine): - continue - link = windows / folder / (name + ".bl-new") - backup = windows / folder / (name + FOREIGN_SUFFIX) - serial = 1 - while os.path.lexists(backup): - backup = windows / folder / (name + FOREIGN_SUFFIX + ".%d" % serial) - serial += 1 + except OSError: + continue + backup = newest_foreign_backup(backups) + if backup is None or backup.is_symlink() or not backup.is_file(): + continue + machine = pe_machine(backup) + if machine is None or not PE["machine_compatible"](backup, machines, machine, builtins, name): + continue + try: + os.replace(backup, path) + except OSError: + continue + restored.append("%s/%s (machine 0x%x)" % (folder, name, machine)) + return restored + + +def repair_foreign_system_dlls(prefix, proton, env=None): + repaired = [] + for folder, name, path, source, machines, builtins, backups in prefix_system_dlls(prefix, proton, env): + if path.is_symlink() or not path.is_file(): + continue + machine = pe_machine(path) + if machine is None or PE["machine_compatible"](path, machines, machine, builtins): + continue + link = path.parent / (name + ".bl-new") + backup = path.parent / (name + FOREIGN_SUFFIX) + if backups: + backup = path.parent / (name + FOREIGN_SUFFIX + ".%d" % (backups[-1][0] + 1)) + try: + os.symlink(os.path.relpath(source, path.parent), link) + os.replace(path, backup) try: - os.symlink(os.path.relpath(source, path.parent), link) - os.replace(path, backup) - try: - os.replace(link, path) - except OSError: - if not os.path.lexists(path) and os.path.lexists(backup): - os.replace(backup, path) - raise + os.replace(link, path) except OSError: - if link.is_symlink(): - link.unlink() - continue - repaired.append("%s/%s (machine 0x%x)" % (folder, name, machine)) + if not os.path.lexists(path) and os.path.lexists(backup): + os.replace(backup, path) + raise + except OSError: + if link.is_symlink(): + link.unlink() + continue + repaired.append("%s/%s (machine 0x%x)" % (folder, name, machine)) return repaired @@ -1242,7 +1297,7 @@ def main(): return 2 env = game_gpu(os.environ.copy()) mic_enabled = env.get("BL_MIC_ENABLED") - debug_dir = env.get("BL_DEBUG_DIR", "") + debug_dir = session_debug_dir(env) prefix_path = env.get("STEAM_COMPAT_DATA_PATH", "").rstrip("/") app_id = game_id(env) components = "" @@ -1272,10 +1327,14 @@ def main(): components = win_components(prefix_path, app_id, command[0], effective_env) if prefix_path and command: try: + restored = restore_compatible_system_dlls(prefix_path, command[0], effective_env) fixed = repair_foreign_system_dlls(prefix_path, command[0], effective_env) except OSError as error: - fixed = [] + restored = fixed = [] print("droiddeck-game-env: prefix system DLL check skipped (%s)" % error, file=sys.stderr) + if restored: + print("droiddeck-game-env: restored system DLLs this Proton's own programs do not load: %s" % ", ".join(restored), + file=sys.stderr) if fixed: print("droiddeck-game-env: replaced foreign-architecture system DLLs with this Proton's own: %s" % ", ".join(fixed), file=sys.stderr) @@ -1300,6 +1359,8 @@ def main(): fixes = {} if waiting: command = skip_red_launcher(command) + if len(command) > 2: + death_stranding_allocator(app_id, command[2]) ubisoft_overlay_off(env) project_zomboid_jvm(command) fixes, extra, notes = engine_fixes(command[2], command[3:]) if len(command) > 2 else ({}, [], []) @@ -1320,6 +1381,9 @@ def main(): if "vblank_mode" in config.get("shared", {}): fixes.pop("vblank_mode", None) env = apply_config(env, launch_config, app_id, fixes) + note = keyboard_helper_off(env) + if note: + print("droiddeck-game-env: " + note, file=sys.stderr) else: path = Path.home() / ".config/droiddeck/game-environment.json" try: diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index 90bd191b4d..ce6ef1e615 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -972,6 +972,7 @@ case $mode in bl_session_pressure() { bl_memory_read [ "$_bl_game" = 1 ] && bl_memory_critical || return 0 + [ "${BL_ZRAM_IDLE:-1}" = 1 ] && bl_game_focused 0 || return 0 local _wait=$_bl_tier_backoff _before _pids _targets [ "$_bl_available" -ge $((_bl_headroom / 2)) ] || [ "$_bl_tier_pushed" -lt 0 ] || _wait=30 [ "$_bl_tier_at" -lt 0 ] || [ $((SECONDS - _bl_tier_at)) -ge "$_wait" ] || return 0 @@ -1103,7 +1104,7 @@ case $mode in local id id=$(sed -n 's/.*"focusedApp"[[:space:]]*:[[:space:]]*\([0-9][0-9]*\).*/\1/p' \ "$BL_LAUNCH_DIR/agent/focus.json" 2>/dev/null | head -1) - [ -n "$id" ] || return 1 + [ -n "$id" ] || return "${1:-1}" case " ${_bl_apps-} " in *" $id "*) return 0 ;; esac diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-wincomponents b/tools/linuxfs/overlay/usr/local/bin/droiddeck-wincomponents index dde2d6e6be..e196f6fa33 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-wincomponents +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-wincomponents @@ -479,13 +479,15 @@ def save_state(compat, state): os.replace(temp, compat / STATE) -def foreign_component(rel, path, machines): +def foreign_component(rel, path, machines, dist=None): parts = Path(rel).parts folder = parts[2] if len(parts) > 2 and parts[:2] == ("drive_c", "windows") else None if not machines or folder not in PE_MACHINES or not rel.lower().endswith(".dll"): return False machine = pe_machine(path) - return machine is not None and not machine_compatible(path, machines[folder][1], machine) + libdir, compatible = machines[folder] + builtins = dist / libdir if dist else None + return machine is not None and not machine_compatible(path, compatible, machine, builtins) def pending_for(app_id, pending=PENDING): @@ -546,6 +548,7 @@ def apply(compat_path, app_id, selection=SELECTION, store=STORE, pending=PENDING skipped = set() placed_stems = set() machines = PE["proton_pe_machines"](proton, env) if proton else None + dist = Path(proton).parent / "files/lib/wine" if proton else None saved_overrides = state.get("overrides") if isinstance(state.get("overrides"), dict) else {} saved_requires = state.get("requires") if isinstance(state.get("requires"), dict) else {} recorded = [c for c in state.get("components", []) if isinstance(c, str) and valid_id(c)] @@ -585,7 +588,7 @@ def apply(compat_path, app_id, selection=SELECTION, store=STORE, pending=PENDING kept_requires[cid] = list(requires) values += [(cid, value) for value in registry] for rel, src in files: - foreign = foreign_component(rel, src, machines) + foreign = foreign_component(rel, src, machines, dist) if foreign: skipped.add(Path(rel).stem.lower()) changed = False @@ -606,7 +609,7 @@ def apply(compat_path, app_id, selection=SELECTION, store=STORE, pending=PENDING path = existing(pfx / rel) saved = compat / BACKUP / rel if saved.is_file(): - if foreign_component(rel, saved, machines): + if foreign_component(rel, saved, machines, dist): if path is not None and not path.is_symlink(): path.unlink() continue diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-wine-pe b/tools/linuxfs/overlay/usr/local/bin/droiddeck-wine-pe index 65c3446a2a..c4f4469b6c 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-wine-pe +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-wine-pe @@ -1,5 +1,5 @@ #!/usr/bin/python3 -import re +import os from pathlib import Path @@ -76,18 +76,105 @@ def pe_has_arm64ec_metadata(path): return False -# Only x64 code and members of the same runtime family import these, so an x64 copy loads in an -# ARM64EC prefix, and games check for a newer version than Wine's builtins report. -VC_RUNTIME = re.compile(r"(msvc[pr]\d.*|vcruntime\d.*|vcomp\d*|vcamp\d.*|vccorlib\d.*|concrt\d.*|mfcm?\d.*)\.dll", - re.IGNORECASE) +def pe_imports(path): + try: + with open(path, "rb") as source: + image = source.read() + except OSError: + return None + try: + if image[:2] != b"MZ": + return None + pe_offset = int.from_bytes(image[60:64], "little") + if image[pe_offset:pe_offset + 4] != b"PE\0\0": + return None + section_count = int.from_bytes(image[pe_offset + 6:pe_offset + 8], "little") + optional_size = int.from_bytes(image[pe_offset + 20:pe_offset + 22], "little") + optional = pe_offset + 24 + magic = int.from_bytes(image[optional:optional + 2], "little") + directories = optional + (112 if magic == 0x20B else 96) + if directories > len(image): + return None + directory_count = int.from_bytes(image[directories - 4:directories], "little") + sections = [] + for index in range(min(section_count, 96)): + entry = optional + optional_size + index * 40 + if entry + 40 > len(image): + return None + sections.append((int.from_bytes(image[entry + 12:entry + 16], "little"), + max(int.from_bytes(image[entry + 8:entry + 12], "little"), + int.from_bytes(image[entry + 16:entry + 20], "little")), + int.from_bytes(image[entry + 20:entry + 24], "little"))) + + def offset(rva): + for address, size, raw in sections: + if address <= rva < address + size: + return rva - address + raw + return None + + names = set() + for directory, step, field in ((1, 20, 12), (13, 32, 4)): + if directory >= directory_count: + continue + if directories + directory * 8 + 8 > len(image): + return None + rva = int.from_bytes(image[directories + directory * 8:directories + directory * 8 + 4], "little") + entry = offset(rva) if rva else None + if rva and entry is None: + return None + while entry is not None: + if entry + step > len(image): + return None + name_rva = int.from_bytes(image[entry + field:entry + field + 4], "little") + if not name_rva: + break + name = offset(name_rva) + end = image.find(b"\0", name) if name is not None else -1 + if end < 0: + return None + names.add(image[name:end].decode("ascii", "replace").lower()) + entry += step + return names + except (IndexError, ValueError): + return None -def machine_compatible(path, machines, machine=None): +PROGRAM_IMPORTS = {} + + +def program_imports(builtins): + key = str(builtins) + if key not in PROGRAM_IMPORTS: + try: + files = {name.lower(): Path(builtins) / name for name in os.listdir(builtins)} + except OSError: + files = None + pending = [name for name in files or () if name.endswith(".exe") and pe_machine(files[name]) in (None, 0xAA64)] + seen = set() + while pending and files is not None: + name = pending.pop() + if name in seen: + continue + seen.add(name) + if name in files: + imports = pe_imports(files[name]) + if imports is None: + files = None + else: + pending.extend(imports) + PROGRAM_IMPORTS[key] = None if files is None else frozenset(name for name in seen if name.endswith(".dll")) + return PROGRAM_IMPORTS[key] + + +def machine_compatible(path, machines, machine=None, builtins=None, name=None): machine = pe_machine(path) if machine is None else machine - if machine == 0x8664 and 0xA641 in machines and VC_RUNTIME.fullmatch(Path(path).name): - return True + if machine == 0x8664 and 0xA641 in machines: + if pe_has_arm64ec_metadata(path): + return True + imported = program_imports(builtins) if builtins is not None else None + return imported is not None and (name or Path(path).name).lower() not in imported if machine == 0x8664 and pe_has_arm64ec_metadata(path): - return 0xA641 in machines + return False return machine in machines diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-xbox b/tools/linuxfs/overlay/usr/local/bin/droiddeck-xbox index 304e126552..5a9f2578ca 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-xbox +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-xbox @@ -197,6 +197,172 @@ def wine(argv, source_env=None): pass +# PlayFab Game Saves picks its provider from the Gaming Runtime unless HKLM\SOFTWARE\Microsoft\GamingServices +# ForceUseInprocGameSaves is set, and its in-process provider needs a save folder the title never passes on Windows. +# The runtime has no GRTS saves, so titles such as Forza Horizon 6 stop with E:0-17. xodus-nexus ships a proxy +# (scripts/runtime-compat/playfab-save-folder.c, MIT) that keeps the title's own SDK as nexus_pgs_native.dll and +# supplies both; this stages it the same way. +PGS_PROXY = RUNTIME / 'compat' / 'PlayFabGameSave.dll' +PGS_NATIVE = 'nexus_pgs_native.dll' +PGS_EXPORTS = ( + 'PFGameSaveFilesAddUserWithUiAsync', 'PFGameSaveFilesAddUserWithUiResult', 'PFGameSaveFilesGetFolder', + 'PFGameSaveFilesGetFolderSize', 'PFGameSaveFilesGetRemainingQuota', 'PFGameSaveFilesGetSaveDescriptionForDebug', + 'PFGameSaveFilesGetSaveDescriptionSizeForDebug', 'PFGameSaveFilesGetStatsJsonForDebug', + 'PFGameSaveFilesGetStatsJsonSizeForDebug', 'PFGameSaveFilesInitialize', 'PFGameSaveFilesIsConnectedToCloud', + 'PFGameSaveFilesPauseUploadForDebug', 'PFGameSaveFilesResetCloudAsync', 'PFGameSaveFilesResetCloudResult', + 'PFGameSaveFilesResumeUploadForDebug', 'PFGameSaveFilesSetActiveDeviceChangedCallback', + 'PFGameSaveFilesSetActiveDevicePollForceChangeForDebug', 'PFGameSaveFilesSetActiveDevicePollIntervalForDebug', + 'PFGameSaveFilesSetForceNullPendingManifestForDebug', 'PFGameSaveFilesSetForceOutOfStorageErrorForDebug', + 'PFGameSaveFilesSetForceSyncFailedErrorForDebug', 'PFGameSaveFilesSetMockDataFolderForDebug', + 'PFGameSaveFilesSetMockDeviceIdForDebug', 'PFGameSaveFilesSetMockForceOfflineForDebug', + 'PFGameSaveFilesSetMockManifestOffsetForDebug', 'PFGameSaveFilesSetMockRootFolderForDebug', + 'PFGameSaveFilesSetSaveDescriptionAsync', 'PFGameSaveFilesSetSaveDescriptionResult', + 'PFGameSaveFilesSetUiActiveDeviceContentionResponse', 'PFGameSaveFilesSetUiCallbacks', + 'PFGameSaveFilesSetUiConflictResponse', 'PFGameSaveFilesSetUiOutOfStorageResponse', + 'PFGameSaveFilesSetUiProgressResponse', 'PFGameSaveFilesSetUiSyncFailedResponse', + 'PFGameSaveFilesSetWriteManifestsToDiskForDebug', 'PFGameSaveFilesUiProgressGetProgress', + 'PFGameSaveFilesUninitializeAsync', 'PFGameSaveFilesUninitializeResult', 'PFGameSaveFilesUploadWithUiAsync', + 'PFGameSaveFilesUploadWithUiResult', +) + + +def pe_exports(data): + """(export address table size, [(name, ordinal index, forwarder or None) for each named export]) of an x64 + PE image, or None. The table size also counts exports that have no name.""" + def u16(offset): + return int.from_bytes(data[offset:offset + 2], 'little') + + def u32(offset): + return int.from_bytes(data[offset:offset + 4], 'little') + + def string(offset): + end = data.find(b'\0', offset) + return None if offset is None or end < 0 else data[offset:end].decode('ascii', 'replace') + + if len(data) < 256 or data[:2] != b'MZ': + return None + pe = u32(60) + if data[pe:pe + 4] != b'PE\0\0' or u16(pe + 4) != 0x8664: + return None + count, optional_size = u16(pe + 6), u16(pe + 20) + optional = pe + 24 + if optional_size < 120 or u16(optional) != 0x20B or u32(optional + 108) < 1: + return None + sections = optional + optional_size + + def offset_of(address): + for index in range(count): + section = sections + index * 40 + start, size, raw = u32(section + 12), u32(section + 16), u32(section + 20) + if start <= address < start + size and raw + address - start < len(data): + return raw + address - start + return None + + directory_rva, directory_size = u32(optional + 112), u32(optional + 116) + directory = offset_of(directory_rva) + if directory is None or u32(directory + 16) != 1: + return None + functions, names = u32(directory + 20), u32(directory + 24) + function_table, name_table, ordinal_table = (offset_of(u32(directory + 28)), offset_of(u32(directory + 32)), + offset_of(u32(directory + 36))) + if None in (function_table, name_table, ordinal_table): + return None + exports = [] + for index in range(names): + name = string(offset_of(u32(name_table + 4 * index))) + ordinal = u16(ordinal_table + 2 * index) + address = u32(function_table + 4 * ordinal) if ordinal < functions else 0 + if name is None or not address: + return None + forward = string(offset_of(address)) if directory_rva <= address < directory_rva + directory_size else None + exports.append((name, ordinal, forward)) + return functions, exports + + +def playfab_sdk(data): + """The PlayFab Game Saves SDK the proxy was written for: exactly its 40 exports, all named, none forwarded.""" + parsed = pe_exports(data) + if parsed is None or parsed[0] != len(PGS_EXPORTS): + return False + exports = parsed[1] + return ([(name, ordinal) for name, ordinal, _ in exports] == list(zip(PGS_EXPORTS, range(len(PGS_EXPORTS)))) + and all(forward is None for _, _, forward in exports)) + + +def playfab_proxy(data): + """A save-folder proxy (this one or an earlier build): the same 40 exports, forwarding into nexus_pgs_native.""" + parsed = pe_exports(data) + if parsed is None or parsed[0] != len(PGS_EXPORTS): + return False + exports = parsed[1] + return ([name for name, _, _ in exports] == list(PGS_EXPORTS) + and any((forward or '').startswith(PGS_NATIVE[:-4] + '.') for _, _, forward in exports)) + + +def kept_sdk(native): + """True when nexus_pgs_native.dll is a regular file holding a recognised SDK.""" + return not native.is_symlink() and native.is_file() and playfab_sdk(native.read_bytes()) + + +def replace_file(directory, name, data): + descriptor, temporary = tempfile.mkstemp(prefix='.droiddeck-pgs-', dir=directory) + try: + with os.fdopen(descriptor, 'wb') as file: + file.write(data) + file.flush() + os.fsync(file.fileno()) + os.chmod(temporary, 0o644) + os.replace(temporary, Path(directory) / name) + except BaseException: + try: + os.unlink(temporary) + except OSError: + pass + raise + + +def stage_playfab_proxy(folder): + """Put the save-folder proxy in front of every PlayFab Game Saves SDK in the game folder. Returns how many.""" + try: + proxy = PGS_PROXY.read_bytes() + except OSError: + return 0 + staged = 0 + for root, _, files in os.walk(folder): + directory = Path(root) + for name in files: + if name.lower() != 'playfabgamesave.dll': + continue + path = directory / name + native = directory / PGS_NATIVE + try: + if path.is_symlink(): + continue + data = path.read_bytes() + if playfab_sdk(data): + # A first launch, or a game update that brought a new SDK: the update's copy becomes the native one, + # but only in place of nothing or of an earlier SDK copy, never over an unknown file or a link. + if os.path.lexists(native) and not kept_sdk(native): + print('droiddeck-xbox: unknown %s next to the PlayFab Game Saves SDK in %s; left unchanged' + % (PGS_NATIVE, directory), file=sys.stderr) + continue + replace_file(directory, PGS_NATIVE, data) + elif not playfab_proxy(data): + print('droiddeck-xbox: PlayFab Game Saves SDK with unknown exports in %s; left unchanged' % directory, + file=sys.stderr) + continue + elif not kept_sdk(native): + print('droiddeck-xbox: PlayFab save proxy without its SDK in %s; left unchanged' % directory, + file=sys.stderr) + continue + if data != proxy: + replace_file(directory, name, proxy) + staged += 1 + except OSError as error: + print('droiddeck-xbox: PlayFab save proxy not staged in %s (%s)' % (directory, error), file=sys.stderr) + return staged + + def renew_lease(ask, channel, product, lease, stopped): while not stopped.wait(15): response = ask(channel, {'op': 'xbox-renew', 'id': product, 'lease': lease}, timeout=10) @@ -255,6 +421,12 @@ def launch(command, env): pass if roots: owned_env['XODUS_CONTENT_ROOTS'] = ';'.join(roots) + # No DLL override for the proxy or the kept SDK: Wine has no builtin of either, so both load from the + # game folder as they are. Forcing them native-only (as Nexus does) made Forza Horizon 6 fail with E:0-0-4. + try: + stage_playfab_proxy(folder) + except Exception as error: + print('droiddeck-xbox: PlayFab save proxy skipped (%s)' % error, file=sys.stderr) return wine([reply['exe']], owned_env) finally: stopped.set() diff --git a/tools/release/retire_test_builds.py b/tools/release/retire_test_builds.py new file mode 100755 index 0000000000..d2ddb7f8fe --- /dev/null +++ b/tools/release/retire_test_builds.py @@ -0,0 +1,62 @@ +#!/usr/bin/env python3 +"""Deletes test builds nobody can still need: a closed PR's at once, a merged PR's once a Preview build carries the merge.""" + +from __future__ import annotations + +import argparse +import os +import re +import sys + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from update_catalog import ApiError, GitHub, current_file, in_preview, previous_catalog, q # noqa: E402 + +TEST_TAG = re.compile(r"^pr-([1-9][0-9]*)(\.0)?$") + + +def retired(pull: dict, source: GitHub, repo: str, preview_commit: str | None) -> bool: + if pull.get("state") == "open": + return False + if not pull.get("merged_at"): + return True + return in_preview(source, repo, pull, preview_commit) + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("--source-repo", default=os.environ.get("GITHUB_REPOSITORY", "Droid-Deck/DroidDeck")) + parser.add_argument("--ci-repo", default="Droid-Deck/DroidDeck-CI") + parser.add_argument("--pr", type=int, help="only this PR's test build") + args = parser.parse_args() + source = GitHub(os.environ.get("SOURCE_GITHUB_TOKEN", "")) + ci = GitHub(os.environ["CI_GITHUB_TOKEN"]) + catalog = previous_catalog(current_file(ci, args.ci_repo, "catalog.json")) or {} + preview_commit = (catalog.get("preview") or {}).get("commit") + failed = False + for release in ci.get_all(f"/repos/{args.ci_repo}/releases"): + tag = release.get("tag_name") or "" + match = TEST_TAG.fullmatch(tag) + if not match or (args.pr and int(match.group(1)) != args.pr): + continue + number = int(match.group(1)) + try: + pull = source.get(f"/repos/{args.source_repo}/pulls/{number}") + if not retired(pull, source, args.source_repo, preview_commit): + print(f"Keeping {tag}: PR #{number} is {'open' if pull.get('state') == 'open' else 'merged, not yet in a Preview build'}") + continue + ci.request("DELETE", f"/repos/{args.ci_repo}/releases/{release['id']}") + try: + ci.request("DELETE", f"/repos/{args.ci_repo}/git/refs/tags/{q(tag)}") + except ApiError as e: + if e.status not in (404, 422): + raise + print(f"Deleted {tag}") + except ApiError as e: + print(f"{tag}: {e}", file=sys.stderr) + failed = True + return 1 if failed else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/release/runtime_inputs.py b/tools/release/runtime_inputs.py index 12ac22eabb..17b67722cf 100644 --- a/tools/release/runtime_inputs.py +++ b/tools/release/runtime_inputs.py @@ -109,7 +109,8 @@ def required(): ['comet', 'GalaxyCommunication.exe', 'update-permissions.exe', 'LICENSE', 'version']] paths += ['assets/linuxfs/usr/local/lib/droiddeck-xbox/' + name for name in ['xodus-cli', 'xodus-service', 'version', 'backend.lock.json', 'runtime.lock.json', 'LICENSE.xodus', 'LICENSE.nexus', 'LICENSE.LGPL-2.1', 'LICENSE.nghttp2', - 'windows/xgameruntime.dll', 'windows/winhttp.dll', 'windows/windows.web.dll', 'windows/twinapi.appcore.dll', 'windows/libnghttp2.dll']] + 'windows/xgameruntime.dll', 'windows/winhttp.dll', 'windows/windows.web.dll', 'windows/twinapi.appcore.dll', 'windows/libnghttp2.dll', + 'compat/PlayFabGameSave.dll', 'LICENSE.runtime-compat']] for driver in ['linux-wine11', 'linux-wine11-systhread']: paths += ['assets/directaudio/' + driver + '/' + name for name in ['aarch64-unix/winedirectaudio.so', 'aarch64-windows/winedirectaudio.drv', diff --git a/tools/release/sign-apk.sh b/tools/release/sign-apk.sh index a7cfd8f531..15fbb4e33c 100755 --- a/tools/release/sign-apk.sh +++ b/tools/release/sign-apk.sh @@ -40,23 +40,37 @@ if [ "$pkg" != "$P" ]; then && die "$variant: the manifest still names $P in an authority or task" fi -"$BUILD_TOOLS/zipalign" -p -f 4 "$work/renamed.apk" "$work/aligned.apk" - "$BUILD_TOOLS/apksigner" rotate --out "$work/lineage" \ --old-signer --ks "$TESTKEY" --ks-type PKCS12 --ks-pass env:TESTKEY_PASSWORD \ --ks-key-alias testkey --key-pass env:TESTKEY_PASSWORD --set-rollback false \ --new-signer --ks "$RELEASE_KEYSTORE" --ks-type PKCS12 --ks-pass env:RELEASE_STORE_PASSWORD \ --ks-key-alias "$RELEASE_KEY_ALIAS" --key-pass env:RELEASE_STORE_PASSWORD -"$BUILD_TOOLS/apksigner" sign \ - --ks "$TESTKEY" --ks-type PKCS12 --ks-pass env:TESTKEY_PASSWORD \ - --ks-key-alias testkey --key-pass env:TESTKEY_PASSWORD \ - --next-signer --ks "$RELEASE_KEYSTORE" --ks-type PKCS12 --ks-pass env:RELEASE_STORE_PASSWORD \ - --ks-key-alias "$RELEASE_KEY_ALIAS" --key-pass env:RELEASE_STORE_PASSWORD \ - --lineage "$work/lineage" --rotation-min-sdk-version 28 \ - --v1-signing-enabled true --v2-signing-enabled true --v3-signing-enabled true --v4-signing-enabled false \ - --out "$out" "$work/aligned.apk" -rm -f "$out.idsig" +sign() { + "$BUILD_TOOLS/apksigner" sign \ + --ks "$TESTKEY" --ks-type PKCS12 --ks-pass env:TESTKEY_PASSWORD \ + --ks-key-alias testkey --key-pass env:TESTKEY_PASSWORD \ + --next-signer --ks "$RELEASE_KEYSTORE" --ks-type PKCS12 --ks-pass env:RELEASE_STORE_PASSWORD \ + --ks-key-alias "$RELEASE_KEY_ALIAS" --key-pass env:RELEASE_STORE_PASSWORD \ + --lineage "$work/lineage" --rotation-min-sdk-version 28 \ + --v1-signing-enabled true --v2-signing-enabled true --v3-signing-enabled true --v4-signing-enabled false \ + --out "$2" "$1" + rm -f "$2.idsig" +} + +companion=assets/shortcuts.apk +if unzip -l "$work/renamed.apk" "$companion" >/dev/null 2>&1; then + mkdir -p "$work/companion/assets" + unzip -p "$work/renamed.apk" "$companion" > "$work/companion-in.apk" + sign "$work/companion-in.apk" "$work/companion/$companion" + companion_v3=$("$BUILD_TOOLS/apksigner" verify --min-sdk-version 28 --print-certs "$work/companion/$companion" | sed -n 's/^.*Signer.* certificate SHA-256 digest: //p' | sort -u) + [ "$companion_v3" = "$expected" ] || die "$variant: the system keys companion is not signed with DroidDeck's key" + (cd "$work/companion" && zip -q -0 "$work/renamed.apk" "$companion") +fi + +"$BUILD_TOOLS/zipalign" -p -f 4 "$work/renamed.apk" "$work/aligned.apk" + +sign "$work/aligned.apk" "$out" "$BUILD_TOOLS/apksigner" verify --min-sdk-version 26 "$out" >/dev/null || die "$variant: does not verify" listing=$(unzip -l "$out") diff --git a/tools/release/update_catalog.py b/tools/release/update_catalog.py index 8ceadb5fcb..02081c1ccc 100755 --- a/tools/release/update_catalog.py +++ b/tools/release/update_catalog.py @@ -184,8 +184,12 @@ def source_meta(source: GitHub, repo: str, ref: str): return code, version, variants, signer -def asset_for_suffix(assets: list[dict], suffix: str, all_suffixes: list[str]): +def asset_for_suffix(assets: list[dict], suffix: str, all_suffixes: list[str], commit: str = ""): others = [s for s in all_suffixes if s and s != suffix] + # A test build's release briefly holds the previous push's APKs too; the one named for this commit wins. + current = f"-{commit[:7].lower()}{suffix}.apk" if len(commit) >= 7 else None + if current: + assets = sorted(assets, key=lambda a: not (a.get("name") or "").lower().endswith(current)) for asset in assets: name = asset.get("name", "") if not name.endswith(f"{suffix}.apk"): @@ -220,7 +224,7 @@ def release_entry( suffixes = [suffix for _, suffix in variants] apks = {} for package, suffix in variants: - asset = asset_for_suffix(release.get("assets") or [], suffix, suffixes) + asset = asset_for_suffix(release.get("assets") or [], suffix, suffixes, commit) if not asset: continue asset.update( @@ -246,24 +250,30 @@ def release_entry( } +def complete_apks(preview: dict, variants: list[tuple[str, str]]) -> bool: + apks = preview.get("apks") or {} + return set(apks) == {package for package, _ in variants} and all( + SHA256.fullmatch((apk.get("sha256") or "").lower()) and SHA256.fullmatch((apk.get("signerSha256") or "").lower()) + for apk in apks.values() + ) + + +def newest_complete(ordered: list[dict], variants: list[tuple[str, str]]) -> dict | None: + """The Preview to offer and to judge merges by: the newest one whose APKs have all been uploaded.""" + return next((p for p in ordered if complete_apks(p, variants)), None) + + def preview_history_entry(release: dict, preview: dict, variants: list[tuple[str, str]]): tag = release.get("tag_name") or "" tag_match = MAIN_TAG.fullmatch(tag) commit = (preview.get("commit") or "").lower() - expected_packages = {package for package, _ in variants} - apks = preview.get("apks") or {} if ( release.get("draft") or not release.get("prerelease") or not tag_match or not re.fullmatch(r"[0-9a-f]{40}", commit) or not commit.startswith(tag_match.group(1)) - or set(apks) != expected_packages - or any( - not SHA256.fullmatch((apk.get("sha256") or "").lower()) - or not SHA256.fullmatch((apk.get("signerSha256") or "").lower()) - for apk in apks.values() - ) + or not complete_apks(preview, variants) ): return None return { @@ -341,6 +351,38 @@ class Cache: return self.commits[sha] +MERGED_GRACE_DAYS = 3 + + +def in_preview(source: GitHub, repo: str, pull: dict, preview_commit: str | None, now_millis: int | None = None) -> bool: + """Whether the newest Preview build was built from a main that already holds the PR's merge. + + A merge that main's build skips (documentation only) never reaches a Preview build, so after + MERGED_GRACE_DAYS it counts as carried anyway. + """ + merge = pull.get("merge_commit_sha") or "" + merged_at = iso_millis(pull.get("merged_at")) + if not merged_at or not merge: + return False + now = now_millis if now_millis is not None else int(time.time() * 1000) + if now - merged_at > MERGED_GRACE_DAYS * 86_400_000: + return True + if not preview_commit: + return False + try: + status = source.get(f"/repos/{repo}/compare/{q(merge)}...{q(preview_commit)}").get("status") + except ApiError: + return False + return status in ("ahead", "identical") + + +def keeps_test_build(pull: dict) -> bool: + """An open PR keeps its test build; a merged one keeps it until a Preview build carries the merge.""" + if pull.get("draft") or (pull.get("base") or {}).get("ref") != "main": + return False + return pull.get("state") == "open" or bool(pull.get("merged_at")) + + def unique_previews(previews: list[dict]) -> list[dict]: ordered = sorted(previews, key=lambda r: (r.get("committedAt") or r["publishedAt"], r["publishedAt"]), reverse=True) result = [] @@ -381,6 +423,7 @@ def build_catalog(source: GitHub, ci: GitHub, source_repo: str, ci_repo: str, pr previews = [] preview_history = [] tests = [] + merged_pulls: dict[int, dict | None] = {} for release in releases: if release.get("draft"): continue @@ -421,7 +464,7 @@ def build_catalog(source: GitHub, ci: GitHub, source_repo: str, ci_repo: str, pr pull = source.get(f"/repos/{source_repo}/pulls/{pr}") except ApiError: continue - if pull.get("state") != "open" or pull.get("draft") or pull.get("base", {}).get("ref") != "main": + if not keeps_test_build(pull): continue commit = release_body_value(body, "Commit") if not commit or not re.fullmatch(r"[0-9a-f]{7,40}", commit): @@ -443,6 +486,7 @@ def build_catalog(source: GitHub, ci: GitHub, source_repo: str, ci_repo: str, pr except (ApiError, KeyError): pass title, summary = ci_description(release) + merged_pulls[pr] = pull if pull.get("state") != "open" else None tests.append( release_entry( release, @@ -468,6 +512,9 @@ def build_catalog(source: GitHub, ci: GitHub, source_repo: str, ci_repo: str, pr ) ordered = unique_previews(previews) + usable = newest_complete(ordered, main_variants) + newest = usable["commit"] if usable else None + tests = [t for t in tests if not (merged_pulls.get(t["pr"]) and in_preview(source, source_repo, merged_pulls[t["pr"]], newest))] tests.sort(key=lambda r: r["publishedAt"], reverse=True) return { "schema": 1, @@ -476,7 +523,7 @@ def build_catalog(source: GitHub, ci: GitHub, source_repo: str, ci_repo: str, pr "generatedAt": int(time.time() * 1000), "mainVersionCode": main_code, "stable": stable, - "preview": ordered[0] if ordered else None, + "preview": usable, "recentPreviews": recent_previews(preview_history), "previews": ordered, "tests": tests, diff --git a/tools/tests/mali_compat_layer_test.c b/tools/tests/mali_compat_layer_test.c new file mode 100644 index 0000000000..640460685c --- /dev/null +++ b/tools/tests/mali_compat_layer_test.c @@ -0,0 +1,490 @@ +#include "mali_compat.h" + +#include +#include +#include +#include +#include + +VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *interface); + +struct object { void *dispatch; }; +static int instance_table, device_table; +static struct object mock_instance = {&instance_table}; +static struct object mock_lacking = {&instance_table}, mock_capable = {&instance_table}; +static struct object mock_device = {&device_table}, mock_command_buffer = {&device_table}; + +static VkBool32 driver_saw_dual_source; +static uint32_t *driver_code; +static size_t driver_code_count; +static VkPipelineColorBlendAttachmentState driver_attachments[4]; +static uint32_t driver_attachment_count; +static VkColorBlendEquationEXT driver_equations[4]; +static uint32_t driver_equation_count; + +#define MAIN 1 +#define VOID 2 +#define FUNCTION 3 +#define FLOAT 4 +#define VEC4 5 +#define OUTPUT_VEC4 6 +#define COLOR 7 +#define SECOND 8 +#define ONE 9 +#define ONES 10 +#define OUTPUT_FLOAT 11 +#define UINT 12 +#define ZERO 13 +#define LABEL 14 +#define CHANNEL 15 +#define BOUND 16 + +struct spirv { uint32_t w[256]; size_t n; }; + +static void op(struct spirv *s, SpvOp code, uint32_t count, const uint32_t *operands) +{ + s->w[s->n++] = (count + 1) << 16 | code; + for (uint32_t i = 0; i < count; i++) + s->w[s->n++] = operands[i]; +} + +#define OP(s, code, ...) \ + do { \ + const uint32_t operands_[] = {__VA_ARGS__}; \ + op(s, code, sizeof(operands_) / sizeof(operands_[0]), operands_); \ + } while (0) + +static void fragment_shader(struct spirv *s, uint32_t version, bool dual_source) +{ + s->n = 0; + const uint32_t header[5] = {SpvMagicNumber, version, 0, BOUND, 0}; + memcpy(s->w, header, sizeof(header)); + s->n = 5; + OP(s, SpvOpCapability, SpvCapabilityShader); + OP(s, SpvOpMemoryModel, SpvAddressingModelLogical, SpvMemoryModelGLSL450); + OP(s, SpvOpEntryPoint, SpvExecutionModelFragment, MAIN, 0x6e69616d, 0, COLOR, SECOND); + OP(s, SpvOpExecutionMode, MAIN, SpvExecutionModeOriginUpperLeft); + OP(s, SpvOpDecorate, COLOR, SpvDecorationLocation, 0); + if (dual_source) { + OP(s, SpvOpDecorate, COLOR, SpvDecorationIndex, 0); + OP(s, SpvOpDecorate, SECOND, SpvDecorationLocation, 0); + OP(s, SpvOpDecorate, SECOND, SpvDecorationIndex, 1); + } else { + OP(s, SpvOpDecorate, SECOND, SpvDecorationLocation, 1); + } + OP(s, SpvOpTypeVoid, VOID); + OP(s, SpvOpTypeFunction, FUNCTION, VOID); + OP(s, SpvOpTypeFloat, FLOAT, 32); + OP(s, SpvOpTypeVector, VEC4, FLOAT, 4); + OP(s, SpvOpTypePointer, OUTPUT_VEC4, SpvStorageClassOutput, VEC4); + OP(s, SpvOpTypePointer, OUTPUT_FLOAT, SpvStorageClassOutput, FLOAT); + OP(s, SpvOpTypeInt, UINT, 32, 0); + OP(s, SpvOpConstant, FLOAT, ONE, 0x3f800000); + OP(s, SpvOpConstantComposite, VEC4, ONES, ONE, ONE, ONE, ONE); + OP(s, SpvOpConstant, UINT, ZERO, 0); + OP(s, SpvOpVariable, OUTPUT_VEC4, COLOR, SpvStorageClassOutput); + OP(s, SpvOpVariable, OUTPUT_VEC4, SECOND, SpvStorageClassOutput); + OP(s, SpvOpFunction, VOID, MAIN, SpvFunctionControlMaskNone, FUNCTION); + OP(s, SpvOpLabel, LABEL); + OP(s, SpvOpStore, COLOR, ONES); + OP(s, SpvOpStore, SECOND, ONES); + OP(s, SpvOpAccessChain, OUTPUT_FLOAT, CHANNEL, SECOND, ZERO); + OP(s, SpvOpStore, CHANNEL, ONE); + s->w[s->n++] = 1u << 16 | SpvOpReturn; + s->w[s->n++] = 1u << 16 | SpvOpFunctionEnd; +} + +static const uint32_t *find(const uint32_t *w, size_t count, SpvOp code, uint32_t position, uint32_t value) +{ + for (size_t i = 5; i < count; i += w[i] >> 16) { + if ((w[i] & 0xffff) == code && (w[i] >> 16) > position && w[i + position] == value) + return &w[i]; + } + return NULL; +} + +static uint32_t storage_of(const uint32_t *w, size_t count, uint32_t pointer_type) +{ + const uint32_t *type = find(w, count, SpvOpTypePointer, 1, pointer_type); + assert(type); + return type[2]; +} + +static bool in_interface(const uint32_t *w, size_t count, uint32_t id) +{ + const uint32_t *entry = find(w, count, SpvOpEntryPoint, 2, MAIN); + assert(entry); + for (uint32_t i = 5; i < entry[0] >> 16; i++) { + if (entry[i] == id) + return true; + } + return false; +} + +static void save(const char *directory, const char *name, const uint32_t *words, size_t count) +{ + if (!directory) + return; + char path[512]; + snprintf(path, sizeof(path), "%s/%s", directory, name); + FILE *file = fopen(path, "wb"); + assert(file); + assert(fwrite(words, sizeof(uint32_t), count, file) == count); + fclose(file); +} + +static void check_stripped(const uint32_t *w, size_t count, bool second_listed) +{ + assert(!spirv_uses_dual_source(w, count)); + const uint32_t *second = find(w, count, SpvOpVariable, 2, SECOND); + const uint32_t *color = find(w, count, SpvOpVariable, 2, COLOR); + assert(second && second[3] == SpvStorageClassPrivate); + assert(storage_of(w, count, second[1]) == SpvStorageClassPrivate); + assert(color && color[3] == SpvStorageClassOutput && color[1] == OUTPUT_VEC4); + assert(!find(w, count, SpvOpDecorate, 1, SECOND)); + const uint32_t *location = find(w, count, SpvOpDecorate, 1, COLOR); + assert(location && location[2] == SpvDecorationLocation && location[3] == 0); + const uint32_t *channel = find(w, count, SpvOpAccessChain, 2, CHANNEL); + assert(channel && storage_of(w, count, channel[1]) == SpvStorageClassPrivate); + assert(storage_of(w, count, OUTPUT_FLOAT) == SpvStorageClassOutput); + assert(in_interface(w, count, COLOR)); + assert(in_interface(w, count, SECOND) == second_listed); +} + +static void test_spirv(const char *directory) +{ + struct spirv dual, plain; + struct spirv_code out; + + fragment_shader(&dual, 0x00010000, true); + save(directory, "dual-1.0.spv", dual.w, dual.n); + assert(spirv_uses_dual_source(dual.w, dual.n)); + assert(spirv_strip_dual_source(dual.w, dual.n, &out)); + check_stripped(out.words, out.count, false); + save(directory, "stripped-1.0.spv", out.words, out.count); + free(out.words); + + fragment_shader(&dual, 0x00010400, true); + assert(spirv_strip_dual_source(dual.w, dual.n, &out)); + check_stripped(out.words, out.count, true); + save(directory, "stripped-1.4.spv", out.words, out.count); + free(out.words); + + fragment_shader(&plain, 0x00010000, false); + save(directory, "plain-1.0.spv", plain.w, plain.n); + assert(!spirv_uses_dual_source(plain.w, plain.n)); + assert(spirv_strip_dual_source(plain.w, plain.n, &out)); + assert(out.count == plain.n && !memcmp(out.words, plain.w, plain.n * sizeof(uint32_t))); + free(out.words); + + uint32_t truncated[5] = {SpvMagicNumber, 0x00010000, 0, BOUND, 0}; + assert(!spirv_uses_dual_source(truncated, 5)); + assert(!spirv_strip_dual_source(truncated, 5, &out)); +} + +static VkResult VKAPI_CALL mock_create_instance(const VkInstanceCreateInfo *info, const VkAllocationCallbacks *allocator, + VkInstance *instance) +{ + *instance = (VkInstance)&mock_instance; + return VK_SUCCESS; +} + +static void VKAPI_CALL mock_destroy_instance(VkInstance instance, const VkAllocationCallbacks *allocator) {} + +static VkResult VKAPI_CALL mock_extensions(VkPhysicalDevice physical, const char *layer, uint32_t *count, + VkExtensionProperties *properties) +{ + *count = 0; + return VK_SUCCESS; +} + +static void VKAPI_CALL mock_features(VkPhysicalDevice physical, VkPhysicalDeviceFeatures *features) +{ + memset(features, 0, sizeof(*features)); + features->dualSrcBlend = physical == (VkPhysicalDevice)&mock_capable; +} + +static void VKAPI_CALL mock_features2(VkPhysicalDevice physical, VkPhysicalDeviceFeatures2 *features) +{ + mock_features(physical, &features->features); +} + +static void VKAPI_CALL mock_properties(VkPhysicalDevice physical, VkPhysicalDeviceProperties *properties) +{ + memset(properties, 0, sizeof(*properties)); + strcpy(properties->deviceName, "mock"); + properties->limits.maxFragmentDualSrcAttachments = physical == (VkPhysicalDevice)&mock_capable; +} + +static void VKAPI_CALL mock_properties2(VkPhysicalDevice physical, VkPhysicalDeviceProperties2 *properties) +{ + mock_properties(physical, &properties->properties); +} + +static void VKAPI_CALL mock_memory_properties(VkPhysicalDevice physical, VkPhysicalDeviceMemoryProperties *properties) +{ + memset(properties, 0, sizeof(*properties)); +} + +static void VKAPI_CALL mock_format_properties2(VkPhysicalDevice physical, VkFormat format, VkFormatProperties2 *out) +{ + memset(&out->formatProperties, 0, sizeof(out->formatProperties)); +} + +static VkResult VKAPI_CALL mock_image_format_properties2(VkPhysicalDevice physical, + const VkPhysicalDeviceImageFormatInfo2 *info, + VkImageFormatProperties2 *properties) +{ + return VK_ERROR_FORMAT_NOT_SUPPORTED; +} + +static VkResult VKAPI_CALL mock_create_device(VkPhysicalDevice physical, const VkDeviceCreateInfo *info, + const VkAllocationCallbacks *allocator, VkDevice *device) +{ + driver_saw_dual_source = info->pEnabledFeatures && info->pEnabledFeatures->dualSrcBlend; + for (const VkBaseInStructure *p = info->pNext; p; p = p->pNext) { + if (p->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 && + ((const VkPhysicalDeviceFeatures2 *)p)->features.dualSrcBlend) + driver_saw_dual_source = VK_TRUE; + } + VkPhysicalDeviceFeatures supported; + mock_features(physical, &supported); + if (driver_saw_dual_source && !supported.dualSrcBlend) + return VK_ERROR_FEATURE_NOT_PRESENT; + *device = (VkDevice)&mock_device; + return VK_SUCCESS; +} + +static void VKAPI_CALL mock_destroy_device(VkDevice device, const VkAllocationCallbacks *allocator) {} + +static void capture_code(const uint32_t *words, size_t size) +{ + free(driver_code); + driver_code_count = size / sizeof(uint32_t); + driver_code = malloc(size); + memcpy(driver_code, words, size); +} + +static VkResult VKAPI_CALL mock_create_shader_module(VkDevice device, const VkShaderModuleCreateInfo *info, + const VkAllocationCallbacks *allocator, VkShaderModule *module) +{ + capture_code(info->pCode, info->codeSize); + *module = (VkShaderModule)0x1000; + return VK_SUCCESS; +} + +static void VKAPI_CALL mock_destroy_shader_module(VkDevice device, VkShaderModule module, + const VkAllocationCallbacks *allocator) {} + +static VkResult VKAPI_CALL mock_create_graphics_pipelines(VkDevice device, VkPipelineCache cache, uint32_t count, + const VkGraphicsPipelineCreateInfo *infos, + const VkAllocationCallbacks *allocator, VkPipeline *pipelines) +{ + const VkPipelineColorBlendStateCreateInfo *blend = infos[0].pColorBlendState; + driver_attachment_count = blend->attachmentCount; + memcpy(driver_attachments, blend->pAttachments, blend->attachmentCount * sizeof(*driver_attachments)); + const VkShaderModuleCreateInfo *module = infos[0].pStages[0].pNext; + assert(module && module->sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO); + capture_code(module->pCode, module->codeSize); + pipelines[0] = (VkPipeline)0x2000; + return VK_SUCCESS; +} + +static void VKAPI_CALL mock_set_blend_equation(VkCommandBuffer cmd, uint32_t first, uint32_t count, + const VkColorBlendEquationEXT *equations) +{ + for (uint32_t i = 0; i < count; i++) + driver_equations[first + i] = equations[i]; + if (first + count > driver_equation_count) + driver_equation_count = first + count; +} + +#define MOCK(name, function) if (!strcmp(requested, name)) return (PFN_vkVoidFunction)function +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL mock_gipa(VkInstance instance, const char *requested) +{ + MOCK("vkCreateInstance", mock_create_instance); + MOCK("vkDestroyInstance", mock_destroy_instance); + MOCK("vkCreateDevice", mock_create_device); + MOCK("vkEnumerateDeviceExtensionProperties", mock_extensions); + MOCK("vkGetPhysicalDeviceFeatures", mock_features); + MOCK("vkGetPhysicalDeviceFeatures2", mock_features2); + MOCK("vkGetPhysicalDeviceProperties", mock_properties); + MOCK("vkGetPhysicalDeviceProperties2", mock_properties2); + MOCK("vkGetPhysicalDeviceMemoryProperties", mock_memory_properties); + MOCK("vkGetPhysicalDeviceFormatProperties2", mock_format_properties2); + MOCK("vkGetPhysicalDeviceImageFormatProperties2", mock_image_format_properties2); + return NULL; +} + +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL mock_gdpa(VkDevice device, const char *requested) +{ + MOCK("vkDestroyDevice", mock_destroy_device); + MOCK("vkCreateShaderModule", mock_create_shader_module); + MOCK("vkDestroyShaderModule", mock_destroy_shader_module); + MOCK("vkCreateGraphicsPipelines", mock_create_graphics_pipelines); + MOCK("vkCmdSetColorBlendEquationEXT", mock_set_blend_equation); + return NULL; +} + +static PFN_vkGetInstanceProcAddr layer_gipa; +static PFN_vkGetDeviceProcAddr layer_gdpa; + +static VkResult create_device(VkPhysicalDevice physical, const void *chain, const VkPhysicalDeviceFeatures *enabled, + VkDevice *device) +{ + VkLayerDeviceLink link = {NULL, mock_gipa, mock_gdpa}; + VkLayerDeviceCreateInfo loader = {VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, chain, VK_LAYER_LINK_INFO, {&link}}; + VkDeviceCreateInfo info = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, &loader, 0, 0, NULL, 0, NULL, 0, NULL, enabled}; + PFN_vkCreateDevice create = (PFN_vkCreateDevice)layer_gipa((VkInstance)&mock_instance, "vkCreateDevice"); + return create(physical, &info, NULL, device); +} + +static void destroy_device(VkDevice device) +{ + ((PFN_vkDestroyDevice)layer_gdpa(device, "vkDestroyDevice"))(device, NULL); +} + +static const VkPipelineColorBlendAttachmentState dual_attachment = { + VK_TRUE, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_OP_ADD, + VK_BLEND_FACTOR_SRC1_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, VK_BLEND_OP_ADD, 0xf, +}; + +static const VkPipelineColorBlendAttachmentState plain_attachment = { + VK_TRUE, VK_BLEND_FACTOR_DST_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, VK_BLEND_OP_ADD, + VK_BLEND_FACTOR_SRC_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, VK_BLEND_OP_ADD, 0xf, +}; + +static void create_pipeline(VkDevice device, VkPipelineColorBlendAttachmentState *attachments, + VkShaderModuleCreateInfo *module) +{ + VkPipelineShaderStageCreateInfo stage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, module, 0, + VK_SHADER_STAGE_FRAGMENT_BIT, VK_NULL_HANDLE, "main", NULL}; + VkPipelineColorBlendStateCreateInfo blend = {VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, NULL, 0, + VK_FALSE, VK_LOGIC_OP_COPY, 2, attachments, {0}}; + VkGraphicsPipelineCreateInfo info = {.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, .stageCount = 1, + .pStages = &stage, .pColorBlendState = &blend}; + VkPipeline pipeline; + PFN_vkCreateGraphicsPipelines create = + (PFN_vkCreateGraphicsPipelines)layer_gdpa(device, "vkCreateGraphicsPipelines"); + assert(create(device, VK_NULL_HANDLE, 1, &info, NULL, &pipeline) == VK_SUCCESS); + assert(stage.pNext == module && blend.pAttachments == attachments); +} + +static bool same_attachment(const VkPipelineColorBlendAttachmentState *a, const VkPipelineColorBlendAttachmentState *b) +{ + return !memcmp(a, b, sizeof(*a)); +} + +static void test_lacking_device(void) +{ + VkPhysicalDevice physical = (VkPhysicalDevice)&mock_lacking; + VkPhysicalDeviceFeatures features; + ((PFN_vkGetPhysicalDeviceFeatures)layer_gipa((VkInstance)&mock_instance, "vkGetPhysicalDeviceFeatures"))(physical, + &features); + assert(features.dualSrcBlend); + VkPhysicalDeviceFeatures2 queried = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2}; + ((PFN_vkGetPhysicalDeviceFeatures2)layer_gipa((VkInstance)&mock_instance, "vkGetPhysicalDeviceFeatures2"))(physical, + &queried); + assert(queried.features.dualSrcBlend); + VkPhysicalDeviceProperties properties; + ((PFN_vkGetPhysicalDeviceProperties)layer_gipa((VkInstance)&mock_instance, "vkGetPhysicalDeviceProperties"))( + physical, &properties); + assert(properties.limits.maxFragmentDualSrcAttachments == 1); + + VkDevice device; + VkPhysicalDeviceFeatures enabled = {.dualSrcBlend = VK_TRUE}; + assert(create_device(physical, NULL, &enabled, &device) == VK_SUCCESS); + assert(!driver_saw_dual_source && enabled.dualSrcBlend); + destroy_device(device); + + VkPhysicalDeviceFeatures2 chained = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, NULL, {.dualSrcBlend = VK_TRUE}}; + assert(create_device(physical, &chained, NULL, &device) == VK_SUCCESS); + assert(!driver_saw_dual_source && chained.features.dualSrcBlend); + + struct spirv dual; + fragment_shader(&dual, 0x00010300, true); + VkShaderModuleCreateInfo module = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, NULL, 0, dual.n * sizeof(uint32_t), + dual.w}; + VkShaderModule handle; + assert(((PFN_vkCreateShaderModule)layer_gdpa(device, "vkCreateShaderModule"))(device, &module, NULL, &handle) == + VK_SUCCESS); + check_stripped(driver_code, driver_code_count, false); + ((PFN_vkDestroyShaderModule)layer_gdpa(device, "vkDestroyShaderModule"))(device, handle, NULL); + + VkPipelineColorBlendAttachmentState attachments[2] = {dual_attachment, plain_attachment}; + create_pipeline(device, attachments, &module); + check_stripped(driver_code, driver_code_count, false); + assert(module.pCode == dual.w && spirv_uses_dual_source(module.pCode, module.codeSize / sizeof(uint32_t))); + assert(driver_attachment_count == 2); + assert(driver_attachments[0].srcColorBlendFactor == VK_BLEND_FACTOR_ONE); + assert(driver_attachments[0].dstColorBlendFactor == VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA); + assert(driver_attachments[0].srcAlphaBlendFactor == VK_BLEND_FACTOR_SRC_ALPHA); + assert(driver_attachments[0].dstAlphaBlendFactor == VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA); + assert(driver_attachments[0].colorWriteMask == 0xf && driver_attachments[0].blendEnable); + assert(same_attachment(&driver_attachments[1], &plain_attachment)); + assert(same_attachment(&attachments[0], &dual_attachment)); + + VkColorBlendEquationEXT equations[2] = { + {VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_OP_ADD, VK_BLEND_FACTOR_ONE, + VK_BLEND_FACTOR_ZERO, VK_BLEND_OP_ADD}, + {VK_BLEND_FACTOR_DST_COLOR, VK_BLEND_FACTOR_SRC_COLOR, VK_BLEND_OP_ADD, VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, + VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_OP_ADD}, + }; + VkCommandBuffer cmd = (VkCommandBuffer)&mock_command_buffer; + PFN_vkCmdSetColorBlendEquationEXT set_equation = + (PFN_vkCmdSetColorBlendEquationEXT)layer_gdpa(device, "vkCmdSetColorBlendEquationEXT"); + assert(set_equation != (PFN_vkCmdSetColorBlendEquationEXT)mock_set_blend_equation); + set_equation(cmd, 1, 2, equations); + assert(driver_equation_count == 3); + assert(driver_equations[1].srcColorBlendFactor == VK_BLEND_FACTOR_SRC_ALPHA); + assert(driver_equations[1].dstColorBlendFactor == VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA); + assert(driver_equations[1].srcAlphaBlendFactor == VK_BLEND_FACTOR_ONE); + assert(!memcmp(&driver_equations[2], &equations[1], sizeof(equations[1]))); + assert(equations[0].srcColorBlendFactor == VK_BLEND_FACTOR_SRC1_COLOR); + destroy_device(device); +} + +static void test_capable_device(void) +{ + VkPhysicalDevice physical = (VkPhysicalDevice)&mock_capable; + VkPhysicalDeviceProperties properties; + ((PFN_vkGetPhysicalDeviceProperties)layer_gipa((VkInstance)&mock_instance, "vkGetPhysicalDeviceProperties"))( + physical, &properties); + assert(properties.limits.maxFragmentDualSrcAttachments == 1); + + VkDevice device; + VkPhysicalDeviceFeatures enabled = {.dualSrcBlend = VK_TRUE}; + assert(create_device(physical, NULL, &enabled, &device) == VK_SUCCESS && driver_saw_dual_source); + assert(layer_gdpa(device, "vkCreateGraphicsPipelines") == (PFN_vkVoidFunction)mock_create_graphics_pipelines); + assert(layer_gdpa(device, "vkCreateShaderModule") == (PFN_vkVoidFunction)mock_create_shader_module); + assert(layer_gdpa(device, "vkCmdSetColorBlendEquationEXT") == (PFN_vkVoidFunction)mock_set_blend_equation); + destroy_device(device); +} + +int main(int argc, char **argv) +{ + test_spirv(argc > 1 ? argv[1] : NULL); + + setenv("WINEPREFIX", "/nonexistent", 1); + unsetenv("DROIDDECK_MALI_COMPAT"); + unsetenv("DROIDDECK_MALI_COMPAT_TRACE"); + VkNegotiateLayerInterface negotiate = {LAYER_NEGOTIATE_INTERFACE_STRUCT, NULL, 2, NULL, NULL, NULL}; + assert(vkNegotiateLoaderLayerInterfaceVersion(&negotiate) == VK_SUCCESS); + layer_gipa = negotiate.pfnGetInstanceProcAddr; + layer_gdpa = negotiate.pfnGetDeviceProcAddr; + + VkLayerInstanceLink link = {NULL, mock_gipa, NULL}; + VkLayerInstanceCreateInfo loader = {VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO, NULL, VK_LAYER_LINK_INFO, {&link}}; + VkInstanceCreateInfo info = {.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, .pNext = &loader}; + VkInstance instance; + PFN_vkCreateInstance create_instance = (PFN_vkCreateInstance)layer_gipa(NULL, "vkCreateInstance"); + assert(create_instance(&info, NULL, &instance) == VK_SUCCESS); + + test_lacking_device(); + test_capable_device(); + + ((PFN_vkDestroyInstance)layer_gipa(instance, "vkDestroyInstance"))(instance, NULL); + free(driver_code); + printf("mali compat layer ok\n"); + return 0; +} diff --git a/tools/tests/pen_emulation_harness.c b/tools/tests/pen_emulation_harness.c new file mode 100644 index 0000000000..f058e77147 --- /dev/null +++ b/tools/tests/pen_emulation_harness.c @@ -0,0 +1,158 @@ +#include +#include +#include +#include + +#define BTN_LEFT 0x110 +#define BTN_RIGHT 0x111 +#define BTN_MIDDLE 0x112 +#define INPUT_SPACE_W 1920 +#define INPUT_SPACE_H 1080 +#include "input_msg.inc" +#include "pen_state.inc" + +enum { MOTION, PRESS, RELEASE }; +struct event { int kind; uint32_t button; double x, y; int raw_valid; }; +struct constraint { int is_lock; }; +static struct constraint *g_active_constraint; +static struct surface *g_grab; +static int g_raw_valid; +static struct event events[16]; +static int nevents, logs; +static uint32_t held; + +static void scene_size(int *w, int *h) { *w = 3840; *h = 2160; } +static void vkp_output_size(int *w, int *h) { *w = 0; *h = 0; } +static int vkp_output_to_scene(double ox, double oy, double *x, double *y) { + (void)ox; (void)oy; (void)x; (void)y; + return 0; +} +static void pointer_event(double x, double y, uint32_t button, int pressed) { + assert(!button && !pressed && nevents < 16); + events[nevents++] = (struct event){MOTION, 0, x, y, g_raw_valid}; + g_raw_valid = 1; +} +static void pointer_button(uint32_t button, int pressed) { + assert(button >= BTN_LEFT && button <= BTN_MIDDLE && nevents < 16); + uint32_t bit = 1u << (button - BTN_LEFT); + if (pressed) assert(!(held & bit)); + else assert(held & bit); + held = pressed ? held | bit : held & ~bit; + events[nevents++] = (struct event){pressed ? PRESS : RELEASE, button, 0, 0, g_raw_valid}; +} +static void pen_log_target(void) { logs++; } +#include "pen.inc" + +static void pen(int flags, double x, double y) { + struct input_msg m = {13, flags, (int)(x * 256), (int)(y * 256), 0}; + nevents = 0; + deliver_pen(&m); +} + +static void motion(int i, double x, double y) { + assert(events[i].kind == MOTION && events[i].x == x && events[i].y == y); +} + +static void button(int i, int kind, uint32_t code) { + assert(events[i].kind == kind && events[i].button == code); +} + +static void expect(int count, uint32_t buttons) { + assert(nevents == count && held == buttons); + assert(g_pen.buttons == (int)buttons); +} + +#define L (1u << 0) +#define R (1u << 1) +#define M (1u << 2) + +int main(int argc, char **argv) { + assert(argc == 2); + const char *c = argv[1]; + if (!strcmp(c, "hover")) { + pen(PEN_IN, 100.5, 50.25); + expect(1, 0); motion(0, 201, 100.5); + pen(PEN_IN, 2000, -4); + expect(1, 0); motion(0, 3839, 0); + assert(g_pen.in && logs == 2); + pen(0, 2000, -4); + expect(0, 0); + assert(!g_pen.in && logs == 2); + } else if (!strcmp(c, "tip")) { + pen(PEN_IN, 10, 10); + expect(1, 0); + pen(PEN_IN | PEN_TIP, 10, 10); + expect(2, L); motion(0, 20, 20); button(1, PRESS, BTN_LEFT); + pen(PEN_IN | PEN_TIP, 11, 10); + expect(1, L); motion(0, 22, 20); + pen(PEN_IN, 12, 10); + expect(2, 0); motion(0, 24, 20); button(1, RELEASE, BTN_LEFT); + pen(PEN_IN | PEN_TIP, 12, 10); + pen(PEN_IN, 12, 10); + pen(0, 12, 10); + expect(0, 0); + } else if (!strcmp(c, "buttons")) { + pen(PEN_IN | PEN_RIGHT, 10, 10); + expect(2, R); motion(0, 20, 20); button(1, PRESS, BTN_RIGHT); + pen(PEN_IN | PEN_RIGHT | PEN_MIDDLE, 10, 10); + expect(2, R | M); button(1, PRESS, BTN_MIDDLE); + pen(PEN_IN | PEN_MIDDLE | PEN_TIP, 11, 10); + expect(3, L | M); motion(0, 22, 20); button(1, PRESS, BTN_LEFT); button(2, RELEASE, BTN_RIGHT); + pen(PEN_IN | PEN_RIGHT, 12, 10); + expect(4, R); motion(0, 24, 20); button(1, PRESS, BTN_RIGHT); + button(2, RELEASE, BTN_LEFT); button(3, RELEASE, BTN_MIDDLE); + pen(PEN_IN, 12, 10); + expect(2, 0); button(1, RELEASE, BTN_RIGHT); + } else if (!strcmp(c, "out")) { + pen(PEN_IN | PEN_TIP | PEN_RIGHT | PEN_MIDDLE, 10, 10); + expect(4, L | R | M); motion(0, 20, 20); + button(1, PRESS, BTN_LEFT); button(2, PRESS, BTN_RIGHT); button(3, PRESS, BTN_MIDDLE); + pen(PEN_TIP | PEN_RIGHT | PEN_MIDDLE, 30, 30); + expect(3, 0); + button(0, RELEASE, BTN_LEFT); button(1, RELEASE, BTN_RIGHT); button(2, RELEASE, BTN_MIDDLE); + assert(!g_pen.in && !g_pen.buttons); + pen(0, 30, 30); + expect(0, 0); + } else if (!strcmp(c, "lock")) { + struct constraint lock = {1}, confine = {0}; + g_active_constraint = &lock; + pen(PEN_IN, 10, 10); + expect(0, 0); + assert(g_pen.in && logs == 1); + pen(PEN_IN | PEN_TIP, 11, 10); + expect(1, L); button(0, PRESS, BTN_LEFT); + pen(PEN_IN | PEN_TIP, 40, 10); + expect(0, L); + pen(PEN_IN | PEN_RIGHT, 40, 10); + expect(2, R); button(0, PRESS, BTN_RIGHT); button(1, RELEASE, BTN_LEFT); + pen(0, 40, 10); + expect(1, 0); button(0, RELEASE, BTN_RIGHT); + g_active_constraint = &confine; + pen(PEN_IN, 10, 10); + expect(1, 0); motion(0, 20, 20); + } else if (!strcmp(c, "lost")) { + pen(PEN_IN | PEN_TIP, 10, 10); + expect(2, L); motion(0, 20, 20); button(1, PRESS, BTN_LEFT); + pen(0, 10, 10); + expect(1, 0); button(0, RELEASE, BTN_LEFT); + pen(PEN_IN | PEN_TIP | PEN_MIDDLE, 10, 10); + expect(3, L | M); + pen(PEN_IN, 50, 10); + expect(3, 0); motion(0, 100, 20); button(1, RELEASE, BTN_LEFT); button(2, RELEASE, BTN_MIDDLE); + } else { + assert(!strcmp(c, "raw")); + g_raw_valid = 1; + pen(PEN_IN, 10, 10); + assert(!events[0].raw_valid && g_raw_valid); + pen(PEN_IN, 11, 10); + assert(events[0].raw_valid); + pen(PEN_IN | PEN_TIP, 12, 10); + assert(events[0].raw_valid && events[1].raw_valid); + pen(0, 12, 10); + assert(!g_raw_valid); + g_raw_valid = 1; + pen(0, 12, 10); + assert(g_raw_valid); + } + puts("PASS"); +} diff --git a/tools/tests/pen_pointer_harness.c b/tools/tests/pen_pointer_harness.c new file mode 100644 index 0000000000..01dd5b45b9 --- /dev/null +++ b/tools/tests/pen_pointer_harness.c @@ -0,0 +1,182 @@ +#include +#include +#include +#include +#include + +#define BTN_LEFT 0x110 +#define BTN_RIGHT 0x111 +#define BTN_MIDDLE 0x112 +#define INPUT_SPACE_W 1920 +#define INPUT_SPACE_H 1080 +#define WL_POINTER_FRAME_SINCE_VERSION 5 +#define WL_POINTER_BUTTON_STATE_RELEASED 0 +#define WL_POINTER_BUTTON_STATE_PRESSED 1 +#include "input_msg.inc" +#include "pen_state.inc" + +typedef int32_t wl_fixed_t; +struct wl_client { int id; }; +struct wl_resource { struct wl_client *client; }; +struct wl_display { int unused; }; +struct surface { struct wl_resource *resource; int placed, x, y; }; +struct seat_pointer { struct wl_resource *ptr, *focus; }; +struct constraint { int is_lock; struct surface *surface; }; + +static struct wl_client client_a, client_b; +static struct wl_resource surface_a = {&client_a}, surface_b = {&client_b}; +static struct wl_resource pointer_a = {&client_a}, pointer_b = {&client_b}; +static struct surface a = {&surface_a, 1, 0, 0}, b = {&surface_b, 1, 1000, 0}; +static struct seat_pointer g_ptrs[2] = {{&pointer_a, NULL}, {&pointer_b, NULL}}; +static int g_nptrs = 2; +static struct wl_display *g_display; +static struct constraint *g_active_constraint; +static struct surface *g_desktop, *g_grab, *g_key_target, *g_ime_click; +static double g_ptr_x, g_ptr_y, g_raw_x, g_raw_y; +static int g_ptr_known, g_raw_valid; +static atomic_int g_cursor_composite; + +enum { ENTER, LEAVE, PRESS, RELEASE }; +struct event { int kind; struct wl_resource *pointer, *surface; uint32_t button; }; +static struct event events[32]; +static int nevents; + +static void record(int kind, struct wl_resource *pointer, struct wl_resource *surface, uint32_t button) { + assert(nevents < 32); + events[nevents++] = (struct event){kind, pointer, surface, button}; +} + +static void scene_size(int *w, int *h) { *w = 2000; *h = 1000; } +static void vkp_output_size(int *w, int *h) { *w = 0; *h = 0; } +static int vkp_output_to_scene(double ox, double oy, double *x, double *y) { + (void)ox; (void)oy; (void)x; (void)y; + return 0; +} +static struct surface *toplevel_at(double x, double y) { + (void)y; + return x < 1000 ? &a : &b; +} +static void confine_clamp(struct constraint *k, double *x, double *y) { (void)k; (void)x; (void)y; } +static void schedule_render(void) {} +static void publish_query_state(void) {} +static void constraints_focus_entered(struct wl_resource *target, struct wl_client *client) { + (void)target; (void)client; +} +static void droiddeck_text_input_refocus(void) {} +static void pen_log_target(void) {} +static struct surface *dying; +static void wl_display_flush_clients(struct wl_display *display) { + (void)display; + if (!dying || !nevents || events[nevents - 1].kind != RELEASE) return; + if (g_grab == dying) g_grab = NULL; + if (g_pen.grab == dying) g_pen.grab = NULL; + dying = NULL; +} +static uint32_t now_ms(void) { return 0; } +static uint32_t wl_display_next_serial(struct wl_display *display) { (void)display; return 0; } +static int wl_resource_get_version(struct wl_resource *r) { (void)r; return 7; } +static struct wl_client *wl_resource_get_client(struct wl_resource *r) { return r->client; } +static wl_fixed_t wl_fixed_from_double(double d) { return (wl_fixed_t)(d * 256); } +static int send_relative_motion(struct wl_client *client, double dx, double dy) { + (void)client; (void)dx; (void)dy; + return 0; +} +static void wl_pointer_send_enter(struct wl_resource *p, uint32_t serial, struct wl_resource *s, + wl_fixed_t x, wl_fixed_t y) { + (void)serial; (void)x; (void)y; + record(ENTER, p, s, 0); +} +static void wl_pointer_send_leave(struct wl_resource *p, uint32_t serial, struct wl_resource *s) { + (void)serial; + record(LEAVE, p, s, 0); +} +static void wl_pointer_send_motion(struct wl_resource *p, uint32_t t, wl_fixed_t x, wl_fixed_t y) { + (void)p; (void)t; (void)x; (void)y; +} +static void wl_pointer_send_frame(struct wl_resource *p) { (void)p; } +static void wl_pointer_send_button(struct wl_resource *p, uint32_t serial, uint32_t t, uint32_t button, + uint32_t state) { + (void)serial; (void)t; + record(state == WL_POINTER_BUTTON_STATE_PRESSED ? PRESS : RELEASE, p, NULL, button); +} +#include "pointer.inc" +#include "pen.inc" + +static void pen(int flags, double x) { + struct input_msg m = {13, flags, (int)(x * INPUT_SPACE_W / 2000 * 256), 100 * 256, 0}; + nevents = 0; + deliver_pen(&m); +} + +static void focus(int i, struct wl_resource *pointer, struct wl_resource *surface) { + assert(i < nevents && events[i].kind == ENTER && events[i].pointer == pointer && events[i].surface == surface); +} + +static void left(int i, struct wl_resource *pointer, struct wl_resource *surface) { + assert(i < nevents && events[i].kind == LEAVE && events[i].pointer == pointer && events[i].surface == surface); +} + +static void button(int i, int kind, uint32_t code) { + assert(i < nevents && events[i].kind == kind && events[i].pointer == &pointer_a && events[i].button == code); +} + +static void hover_away(void) { + assert(!g_grab); + pen(PEN_IN, 1500); + assert(nevents == 2); + left(0, &pointer_a, &surface_a); focus(1, &pointer_b, &surface_b); +} + +int main(int argc, char **argv) { + assert(argc == 2); + const char *c = argv[1]; + pen(PEN_IN, 500); + assert(nevents == 1); + focus(0, &pointer_a, &surface_a); + pen(PEN_IN | PEN_TIP, 500); + assert(nevents == 1 && g_grab == &a); + button(0, PRESS, BTN_LEFT); + if (!strcmp(c, "side")) { + pen(PEN_IN | PEN_TIP | PEN_RIGHT, 600); + assert(nevents == 1 && g_grab == &a); + button(0, PRESS, BTN_RIGHT); + pen(PEN_IN | PEN_TIP, 700); + assert(nevents == 1 && g_grab == &a); + button(0, RELEASE, BTN_RIGHT); + pen(PEN_IN | PEN_TIP, 1500); + assert(nevents == 0 && g_grab == &a); + pen(PEN_IN, 1500); + assert(nevents == 1); + button(0, RELEASE, BTN_LEFT); + } else if (!strcmp(c, "swap")) { + pen(PEN_IN | PEN_RIGHT, 600); + assert(nevents == 2 && g_grab == &a); + button(0, PRESS, BTN_RIGHT); button(1, RELEASE, BTN_LEFT); + pen(PEN_IN | PEN_RIGHT, 1500); + assert(nevents == 0 && g_grab == &a); + pen(PEN_IN, 1500); + assert(nevents == 1); + button(0, RELEASE, BTN_RIGHT); + } else if (!strcmp(c, "mouse")) { + pointer_button(BTN_RIGHT, 1); + pointer_button(BTN_RIGHT, 0); + pen(PEN_IN | PEN_TIP, 1500); + assert(nevents == 0 && g_grab == &a); + pen(PEN_IN, 1500); + assert(nevents == 1); + button(0, RELEASE, BTN_LEFT); + } else { + assert(!strcmp(c, "gone")); + pen(PEN_IN | PEN_TIP | PEN_RIGHT, 600); + assert(nevents == 1 && g_grab == &a); + dying = &a; + pen(PEN_IN | PEN_TIP, 700); + assert(nevents == 1 && !dying && !g_grab && !g_pen.grab); + button(0, RELEASE, BTN_RIGHT); + pen(PEN_IN, 700); + assert(nevents == 1); + button(0, RELEASE, BTN_LEFT); + } + hover_away(); + puts("PASS"); +} diff --git a/tools/tests/test_battlenet.py b/tools/tests/test_battlenet.py index 2dbe844e72..ec29a48c56 100644 --- a/tools/tests/test_battlenet.py +++ b/tools/tests/test_battlenet.py @@ -47,6 +47,47 @@ class LogTest(Temp): self.assertRegex(log.read_text(), r"^\d{4}-\d\d-\d\d \d\d:\d\d:\d\d \[\d+\] second\n$") +class StoreDebugEnvironmentTest(Temp): + def config(self, enabled): + config = self.tmp / ".config/droiddeck/game-environment.json" + config.parent.mkdir(parents=True, exist_ok=True) + config.write_text(json.dumps({"version": 1, "gameDebugLogs": enabled})) + + def env(self, values=None): + debug_dir = self.tmp / "session" + debug_dir.mkdir(exist_ok=True) + base = {"HOME": str(self.tmp), "BL_DEBUG_DIR": str(debug_dir)} + base.update(values or {}) + return base + + def test_store_proton_command_gets_debug_defaults_when_enabled(self): + self.config(True) + with mock.patch.dict(os.environ, self.env(), clear=True): + result = BNET["proton_env"]() + self.assertEqual(result["PROTON_LOG"], "1") + self.assertEqual(result["DXVK_LOG_LEVEL"], "debug") + self.assertEqual(result["PROTON_LOG_DIR"], str(self.tmp / "session")) + self.assertIn("+seh", result["WINEDEBUG"]) + + def test_store_proton_command_keeps_debug_off_when_disabled(self): + self.config(False) + with mock.patch.dict(os.environ, self.env(), clear=True): + result = BNET["proton_env"]() + self.assertNotIn("PROTON_LOG", result) + self.assertNotIn("DXVK_LOG_LEVEL", result) + + def test_store_proton_command_keeps_user_debug_values(self): + self.config(True) + values = {"PROTON_LOG": "0", "DXVK_LOG_LEVEL": "none", "WINEDEBUG": "-all", "PROTON_LOG_DIR": "/custom"} + with mock.patch.dict(os.environ, self.env(values), clear=True): + result = BNET["proton_env"]() + self.assertEqual(result["PROTON_LOG"], "1") + self.assertEqual(result["DXVK_LOG_LEVEL"], "debug") + self.assertEqual(result["PROTON_LOG_DIR"], str(self.tmp / "session")) + self.assertIn("+seh", result["WINEDEBUG"]) + self.assertIn("-all", result["WINEDEBUG"]) + + class IdTest(unittest.TestCase): def test_the_prefix_id_is_the_shortcut_id_the_app_names(self): self.assertEqual(int(BNET["APP_ID"]), zlib.crc32(b'"droiddeck-battlenet"Battle.net') | 0x80000000) diff --git a/tools/tests/test_directaudio_watchdog.py b/tools/tests/test_directaudio_watchdog.py new file mode 100644 index 0000000000..6e566a9d1c --- /dev/null +++ b/tools/tests/test_directaudio_watchdog.py @@ -0,0 +1,97 @@ +import pathlib +import subprocess +import tempfile +import unittest + + +class DirectAudioWatchdogTest(unittest.TestCase): + def test_recovery_threshold_callback_race_and_forced_exit(self): + source = pathlib.Path('tools/directaudio/sink/module-directaudio-native-sink.c').read_text() + watchdog = source[source.index('static void watchdog('):source.index('static void close_output(')] + callback = source[source.index('static void record_callback('): + source.index('static aaudio_data_callback_result_t out_cb(')] + constants = '\n'.join(line for line in source.splitlines() + if line.startswith(('#define DA_FREEZE_GAP_NS ', '#define DA_CB_STALL_NS ', + '#define DA_HOST_RESTART_STALLS '))) + harness = r''' +#include +#include +#include +#include +#include +#include +typedef void AAudioStream; +struct userdata { + bool watchdog_on; + AAudioStream *aq; + uint64_t wd_last_tick_ns, last_cb_ns; + unsigned int cb_count, wd_last_cb; + uint64_t stall_state; +}; +static uint64_t clock_ns = 10000000000ull; +static unsigned int reopens; +static bool callback_race; +static struct userdata *current; +static uint64_t now_ns(void) { return clock_ns; } +static void request_reopen(struct userdata *u, const char *why) { reopens++; } +#define pa_log(...) ((void)0) +CALLBACK +static bool exchange(uint64_t *value, uint64_t *expected, uint64_t next, + int weak, int success, int failure) { + if (callback_race) { + struct userdata *u = current; + record_callback(u); + __atomic_add_fetch(&u->cb_count, 1, __ATOMIC_SEQ_CST); + } + return __atomic_compare_exchange_n(value, expected, next, weak, success, failure); +} +#define __atomic_compare_exchange_n exchange +WATCHDOG +static void cleanup(void) { _exit(99); } +static void tick(struct userdata *u) { + clock_ns += 1000000000ull; + watchdog(u); +} +int main(int argc, char **argv) { + struct userdata state = {.watchdog_on = true, .aq = (void *)1}; + struct userdata *u = &state; + current = u; + watchdog(u); + if (argc > 1 && strcmp(argv[1], "zero") == 0) { + callback_race = true; + tick(u); + assert(reopens == 0 && (uint32_t) u->stall_state == 0); + return 0; + } + tick(u); + assert(reopens == 1 && (uint32_t) u->stall_state == 1); + tick(u); + assert(reopens == 2 && (uint32_t) u->stall_state == 2); + if (argc > 1 && strcmp(argv[1], "exit") == 0) { + atexit(cleanup); + tick(u); + return 42; + } + callback_race = true; + tick(u); + assert(reopens == 2 && (uint32_t) u->stall_state == 0); + callback_race = false; + tick(u); + assert(reopens == 2 && (uint32_t) u->stall_state == 0); + tick(u); + assert(reopens == 3 && (uint32_t) u->stall_state == 1); + u->watchdog_on = false; + tick(u); + assert(reopens == 3 && (uint32_t) u->stall_state == 1); + return 0; +} +'''.replace('CALLBACK', callback).replace('WATCHDOG', watchdog) + with tempfile.TemporaryDirectory() as folder: + path = pathlib.Path(folder) + (path / 'watchdog.c').write_text(constants + '\n' + harness) + subprocess.run(['cc', '-std=c11', '-Werror', str(path / 'watchdog.c'), + '-o', str(path / 'watchdog')], check=True, capture_output=True) + subprocess.run([str(path / 'watchdog')], check=True, timeout=5) + subprocess.run([str(path / 'watchdog'), 'zero'], check=True, timeout=5) + result = subprocess.run([str(path / 'watchdog'), 'exit'], timeout=5) + self.assertEqual(1, result.returncode) diff --git a/tools/tests/test_droiddeck_epic.py b/tools/tests/test_droiddeck_epic.py index 39304d777d..341df75142 100644 --- a/tools/tests/test_droiddeck_epic.py +++ b/tools/tests/test_droiddeck_epic.py @@ -887,17 +887,28 @@ class BrokerTest(EpicTestCase): folder.mkdir() (folder / ".droiddeck-store.json").write_text(json.dumps({"store": "epic", "id": "Fig", "args": ["-x"]})) (folder / ".droiddeck-launch.bat").write_text('if exist "%~dp0.droiddeck-epic-args" goto client\r\n') + debug_dir = self.tmp / "session" + debug_dir.mkdir() + config = self.home / ".config/droiddeck/game-environment.json" + config.parent.mkdir(parents=True) + config.write_text(json.dumps({"version": 1, "gameDebugLogs": True})) calls = [] def popen(command, env=None, cwd=None, start_new_session=False): - calls.append((command, env.get("DROIDDECK_EPIC_HANDLED"), start_new_session)) + calls.append((command, env.get("DROIDDECK_EPIC_HANDLED"), env.get("BL_DEBUG_DIR"), + env.get("PROTON_LOG"), env.get("WINEDEBUG"), start_new_session)) return mock.Mock(wait=mock.Mock(return_value=7)) running = [] - with mock.patch.object(subprocess, "Popen", popen): - code = G["run_game"]({"exe": str(folder / "Fig.exe"), "args": ["-epicapp=Fig"]}, {"PATH": "/usr/bin"}, running) + with mock.patch.dict(os.environ, {"HOME": str(self.home), "BL_DEBUG_DIR": str(debug_dir), + "PROTON_LOG": "0", "WINEDEBUG": "-all"}), \ + mock.patch.object(subprocess, "Popen", popen): + code = G["run_game"]({"exe": str(folder / "Fig.exe"), "args": ["-epicapp=Fig"]}, + {"PATH": "/usr/bin", "BL_DEBUG_DIR": str(debug_dir)}, running) self.assertEqual(7, code) - self.assertEqual(([G["PROTON_RUN"], str(folder / ".droiddeck-launch.bat")], "1", True), calls[0]) + self.assertEqual(([G["PROTON_RUN"], str(folder / ".droiddeck-launch.bat")], "1", str(debug_dir), "1", + mock.ANY, True), calls[0]) + self.assertIn("+seh", calls[0][4]) self.assertEqual([], running) self.assertEqual(b"-epicapp=Fig -x\r\n", (folder / ".droiddeck-epic-args").read_bytes()) diff --git a/tools/tests/test_droiddeck_fex.py b/tools/tests/test_droiddeck_fex.py index 0758f58d34..10cce2770d 100644 --- a/tools/tests/test_droiddeck_fex.py +++ b/tools/tests/test_droiddeck_fex.py @@ -5,6 +5,7 @@ import json import os import runpy import shutil +import stat import struct import subprocess import sys @@ -473,7 +474,6 @@ class PrepareTest(FexTestCase): for name in names: library = root / "lib" / arch / name expected = sniper if name == "libwayland-cursor.so.0" else provider - self.assertEqual(library.resolve(), (expected / "files/lib" / arch / name).resolve()) self.assertEqual(library.read_bytes(), b"old ABI" if expected == sniper else b"new ABI " + name.encode()) self.assertEqual((root / "lib" / arch / "libffi.so.7").read_bytes(), b"old ffi") self.assertEqual((sniper / "files/lib/x86_64-linux-gnu/libwayland-client.so.0").read_bytes(), b"old ABI") @@ -591,8 +591,7 @@ class PrepareTest(FexTestCase): fex, _ = self.quiet(FEX["prepare"]) for arch in ("x86_64-linux-gnu", "i386-linux-gnu"): for name in names: - self.assertEqual((Path(fex["rootfs"]) / "lib" / arch / name).resolve(), - provider / "files/lib" / arch / name) + self.assertEqual((Path(fex["rootfs"]) / "lib" / arch / name).read_bytes(), b"new") self.assertEqual((sniper / "files/lib" / arch / name).read_bytes(), b"base") @unittest.skipUnless(shutil.which("cc"), "C compiler unavailable") @@ -644,7 +643,7 @@ class PrepareTest(FexTestCase): self.graphics(sniper) base = self.write(sniper / "files/lib/x86_64-linux-gnu/libwayland-client.so.0", b"base wayland") fex, _ = self.quiet(FEX["prepare"]) - self.assertEqual((Path(fex["rootfs"]) / "lib/x86_64-linux-gnu/libwayland-client.so.0").resolve(), base) + self.assertEqual((Path(fex["rootfs"]) / "lib/x86_64-linux-gnu/libwayland-client.so.0").read_bytes(), b"base wayland") def test_provider_symlinks_require_existing_targets_on_both_architectures(self): self.fex_tool() @@ -778,6 +777,72 @@ class PrepareTest(FexTestCase): self.assertIn("built the x86 runtime", said) self.assertNotIn("built the x86 runtime", self.quiet(FEX["prepare"])[1]) + def test_the_built_x86_runtime_holds_nothing_that_leaves_it(self): + self.fex_tool() + sniper = self.runtime() + FEX["materialize"](str(sniper)) + self.graphics(sniper) + os.chmod(sniper / "files/share/ca", 0o750) + self.quiet(FEX["prepare"]) + root = (self.home / ".local/share/droiddeck-fex/rootfs").resolve() + self.assertEqual(stat.S_IMODE(os.stat(root / "share/ca").st_mode), 0o750) + entries = 0 + for directory, dirs, files in os.walk(root): + for name in dirs + files: + path = Path(directory) / name + entries += 1 + if path.is_symlink(): + self.assertFalse(os.path.isabs(os.readlink(path)), path) + self.assertTrue(path.resolve().is_relative_to(root), path) + self.assertGreater(entries, 10) + self.assertEqual((root / "bin/[").read_bytes(), b"blob") + self.assertEqual((root / "share/ca/real.crt").read_bytes(), b"cert") + self.assertFalse(os.path.lexists(root / "ab")) + + def test_guest_writes_do_not_mutate_runtime_blob_files(self): + self.fex_tool() + sniper = self.runtime() + FEX["materialize"](str(sniper)) + self.graphics(sniper) + self.quiet(FEX["prepare"]) + root = self.home / ".local/share/droiddeck-fex/rootfs" + marker = root / ".droiddeck-fex" + stamp = marker.read_text() + marker.write_text("3\n" + stamp.partition("\n")[2]) + source = sniper / "files/ab/cdef-1.bin" + guest = root / "bin/[" + guest.unlink() + os.link(source, guest) + self.assertEqual(os.stat(source).st_ino, os.stat(guest).st_ino) + self.assertIn("built the x86 runtime", self.quiet(FEX["prepare"])[1]) + self.assertNotEqual(os.stat(source).st_ino, os.stat(guest).st_ino) + guest.write_bytes(b"guest mutation") + self.assertEqual(source.read_bytes(), b"blob") + self.assertEqual(guest.read_bytes(), b"guest mutation") + + def test_a_rebuilt_x86_runtime_refreshes_the_steam_client_links_and_drops_read_only_trees(self): + self.fex_tool() + sniper = self.runtime() + FEX["materialize"](str(sniper)) + self.graphics(sniper) + base = sniper / "files" + (base / str(self.home).lstrip("/") / ".steam").mkdir(parents=True) + os.symlink(self.steam / "linuxarm64", base / str(self.home).lstrip("/") / ".steam/sdk64") + self.write(self.steam / "linuxarm64/steamclient.so", elf(183)) + os.chmod(base / "share/ca", 0o500) + self.addCleanup(os.chmod, base / "share/ca", 0o700) + self.quiet(FEX["prepare"]) + rootfs = self.home / ".local/share/droiddeck-fex/rootfs" + os.chmod(rootfs / "share/ca", 0o000) + self.write(self.steam / "linux64/steamclient.so", elf(62)) + self.write(self.steam / "linux32/steamclient.so", elf(3)) + os.utime(self.steam / "steamapps/common/SteamLinuxRuntime_4/steamrt4_platform_4.0.20260928.262390/usr-mtree.txt.gz", ns=(1, 1)) + self.assertIn("built the x86 runtime", self.quiet(FEX["prepare"])[1]) + guest = rootfs / str(self.home).lstrip("/") / ".steam" + self.assertEqual(os.readlink(guest / "sdk64"), str(self.steam / "linux64")) + self.assertEqual(os.readlink(guest / "sdk32"), str(self.steam / "linux32")) + self.assertEqual(sorted(os.listdir(rootfs.parent)), ["config", "lock", "rootfs", "status.json"]) + def test_a_runtime_that_is_not_newer_is_left_out(self): self.fex_tool() sniper = self.runtime() diff --git a/tools/tests/test_droiddeckctl.py b/tools/tests/test_droiddeckctl.py index 1f7e32cdff..9dd7dff676 100644 --- a/tools/tests/test_droiddeckctl.py +++ b/tools/tests/test_droiddeckctl.py @@ -55,6 +55,19 @@ FAKE_ADB = textwrap.dedent('''\ print("Result: Bundle[{json=" + json.dumps(answers) + "}]") elif args[:3] == ["shell", "dumpsys", "display"]: print(config.get("dumpsys_display", "")) + elif args[:3] == ["shell", "dumpsys", "input"]: + print(config.get("dumpsys_input", "")) + elif args[:3] == ["shell", "uinput", "-"]: + entry["stdin"] = sys.stdin.read() + if "uinput_stdout" in config: + print(config["uinput_stdout"]) + else: + for line in entry["stdin"].splitlines(): + command = json.loads(line) + if command["command"] == "sync": + print(json.dumps({"reason": "sync", "id": command["id"], "syncToken": command["syncToken"]})) + elif args[:1] == ["shell"] and len(args) == 2 and "command -v uinput" in args[1]: + print(config.get("uinput_probe", "")) elif args[:3] == ["shell", "dumpsys", "power"]: print(" mWakefulness=Awake") elif args[:3] == ["shell", "dumpsys", "SurfaceFlinger"] and "-dump" in args: @@ -332,6 +345,21 @@ class DroiddeckctlTest(FakeAdbTest): shot = [c for c in self.calls() if c["args"][:2] == ["exec-out", "screencap"]][0] self.assertEqual(["exec-out", "screencap", "-p", "-d", "222"], shot["args"]) + def test_screenshot_with_two_screens_takes_the_main_display(self): + self.configure({}, dumpsys_display=DUMPSYS_DISPLAY) + code, out = self.run_ctl("screenshot", str(self.dir / "shot.png")) + self.assertEqual(0, code) + shot = [c for c in self.calls() if c["args"][:2] == ["exec-out", "screencap"]][0] + self.assertEqual(["exec-out", "screencap", "-p", "-d", "111"], shot["args"]) + + def test_screenshot_with_one_screen_names_no_display(self): + one = DUMPSYS_DISPLAY.split(" Display 4:")[0] + self.configure({}, dumpsys_display=one) + code, out = self.run_ctl("screenshot", str(self.dir / "shot.png")) + self.assertEqual(0, code) + shot = [c for c in self.calls() if c["args"][:2] == ["exec-out", "screencap"]][0] + self.assertEqual(["exec-out", "screencap", "-p"], shot["args"]) + def test_displays(self): self.configure({}, dumpsys_display=DUMPSYS_DISPLAY) code, out = self.run_ctl("displays") diff --git a/tools/tests/test_droiddeckctl_pen.py b/tools/tests/test_droiddeckctl_pen.py new file mode 100644 index 0000000000..a4dcf5cc54 --- /dev/null +++ b/tools/tests/test_droiddeckctl_pen.py @@ -0,0 +1,255 @@ +import json +import unittest +import unittest.mock + +from test_droiddeckctl import FakeAdbTest, ctl + + +def samples(*argv): + return ctl.pen_samples(ctl.build_parser().parse_args(["input", "pen", *argv])) + + +def phases(gesture): + return [s["phase"] for s in gesture] + + +def dumpsys_input(rotation=0, size=(1140, 2616), active=1, frame=None): + other = ("Viewport INTERNAL: displayId=2, uniqueId=local:147, port=147, orientation=0, " + "logicalFrame=[0, 0, 2248, 2480], physicalFrame=[0, 0, 2248, 2480], deviceSize=[2248, 2480], isActive=[0]") + shown = (f"Viewport INTERNAL: displayId=0, uniqueId=local:148, port=148, orientation={rotation}, " + f"logicalFrame=[0, 0, {size[0]}, {size[1]}], physicalFrame=[{', '.join(map(str, frame or (0, 0, *size)))}], " + f"deviceSize=[{size[0]}, {size[1]}], isActive=[{active}]") + reader = (f"Input Reader State (Nums of device: 11):\n Device 6: touchpanel_pen\n {other}\n" + f" Configuration:\n Viewports:\n {other}\n {shown}\n OplusInputReader mMergeEnable = 0\n") + return reader + "\nINPUT MANAGER (dumpsys input)\n\n" + reader + + +def frames(commands): + found, frame = [], {} + for command in commands: + if command["command"] == "inject": + events = command["events"] + for code, value in zip(events[1::3], events[2::3]): + if code == "SYN_REPORT": + found.append(frame) + frame = {} + else: + frame[code] = value + return found + + +class PenSamplesTest(unittest.TestCase): + def test_a_tap_hovers_lands_lifts_and_leaves(self): + gesture = samples("tap", "0.5", "0.5", "--hold", "20") + self.assertEqual(["hover"] * 10 + ["down", "move", "up"] + ["hover"] * 10 + ["out"], phases(gesture)) + times = [s["t"] for s in gesture] + self.assertEqual(sorted(times), times) + self.assertEqual([0, 8, 80, 100, 180, 180], [times[0], times[1], times[10], times[12], times[-2], times[-1]]) + self.assertEqual({0.5}, {s["pressure"] for s in gesture[10:13]}) + self.assertEqual({0}, {s["pressure"] for s in gesture[:10] + gesture[13:]}) + self.assertEqual({(0.5, 0.5, None)}, {(s["x"], s["y"], s["button"]) for s in gesture}) + + def test_without_hover_the_pen_lands_and_leaves_at_once(self): + gesture = samples("tap", "0.5", "0.5", "--hover-ms", "0", "--hold", "0") + self.assertEqual([("down", 0), ("up", 0), ("out", 0)], [(s["phase"], s["t"]) for s in gesture]) + + def test_a_stroke_ramps_pressure_and_tilt(self): + gesture = samples("stroke", "0.25", "0.5", "0.75", "1", "--duration", "100", "--hover-ms", "20", "--rate", "100", + "--pressure", "0.25:0.75", "--tilt-x=-30:30", "--tilt-y", "10") + self.assertEqual(["hover", "hover", "down"] + ["move"] * 9 + ["up", "hover", "hover", "out"], phases(gesture)) + contact = gesture[2:13] + self.assertEqual([(20, 0.25, 0.5, 0.25), (70, 0.5, 0.75, 0.5), (120, 0.75, 1, 0.75)], + [(s["t"], s["x"], s["y"], s["pressure"]) for s in (contact[0], contact[5], contact[-1])]) + self.assertEqual((-30, 30), (gesture[0]["tilt_x"], gesture[-1]["tilt_x"])) + self.assertAlmostEqual(-30 + 60 * 20 / 140, contact[0]["tilt_x"]) + self.assertEqual({10}, {s["tilt_y"] for s in gesture}) + + def test_hover_glides_to_the_target(self): + gesture = samples("hover", "0.25", "0.25", "--to", "0.75", "0.5", "--duration", "300", "--distance", "5") + self.assertEqual(["hover"] * 37 + ["out"], phases(gesture)) + self.assertEqual([(0.25, 0.25), (0.75, 0.5), (0.75, 0.5)], + [(s["x"], s["y"]) for s in (gesture[0], gesture[-2], gesture[-1])]) + self.assertEqual((300, {5}), (gesture[-1]["t"], {s["distance"] for s in gesture})) + + def test_a_side_button_is_held_while_hovering(self): + gesture = samples("button", "secondary", "0.5", "0.5", "--hold", "40") + self.assertEqual([80, 88, 96, 104, 112], [s["t"] for s in gesture if s["button"] == "secondary"]) + self.assertEqual(["hover"] * (len(gesture) - 1) + ["out"], phases(gesture)) + self.assertEqual((200, None), (gesture[-1]["t"], gesture[-2]["button"])) + + +class PenUinputTest(FakeAdbTest): + def setUp(self): + super().setUp() + self.configure({}, dumpsys_input=dumpsys_input()) + + def pen(self, *argv): + return self.run_ctl("input", "pen", *argv) + + def script(self): + [call] = [c for c in self.calls() if c["args"][:3] == ["shell", "uinput", "-"]] + return [json.loads(line) for line in call["stdin"].splitlines()] + + def test_a_stroke_draws_with_a_virtual_direct_pen(self): + code, out = self.pen("stroke", "0.25", "0.5", "0.75", "0.5", "--duration", "100", "--rate", "100", + "--hover-ms", "20", "--pressure", "0.2:1") + self.assertEqual(0, code) + self.assertEqual({"ok": True, "command": "input", "type": "pen", "samples": 16, "deviceSerial": "fake-1", + "viewport": {"display": 0, "rotation": 0, "size": [1140, 2616]}}, + {k: v for k, v in out.items() if k != "ms"}) + self.assertFalse(self.calls("input")) + commands = self.script() + register = commands[0] + bits = {c["type"]: c["data"] for c in register["configuration"]} + self.assertEqual(("register", "virtual", ["EV_KEY", "EV_ABS"], ["INPUT_PROP_DIRECT"]), + (register["command"], register["bus"], bits["UI_SET_EVBIT"], bits["UI_SET_PROPBIT"])) + self.assertEqual({"BTN_TOOL_PEN", "BTN_TOOL_RUBBER", "BTN_TOUCH", "BTN_STYLUS", "BTN_STYLUS2"}, + set(bits["UI_SET_KEYBIT"])) + ranges = {a["code"]: (a["info"]["minimum"], a["info"]["maximum"]) for a in register["abs_info"]} + self.assertEqual({"ABS_X": (0, 1140 * 16 - 1), "ABS_Y": (0, 2616 * 16 - 1), "ABS_PRESSURE": (0, 4095), + "ABS_DISTANCE": (0, 255), "ABS_TILT_X": (-90, 90), "ABS_TILT_Y": (-90, 90)}, ranges) + self.assertEqual(set(bits["UI_SET_ABSBIT"]), set(ranges)) + self.assertEqual({"id": 1, "command": "delay", "duration": 1000}, commands[1]) + self.assertNotIn("updateTimeBase", [c["command"] for c in commands]) + self.assertEqual(140, sum(c["duration"] for c in commands[2:-2] if c["command"] == "delay")) + self.assertEqual([{"id": 1, "command": "delay", "duration": 300}, + {"id": 1, "command": "sync", "syncToken": ctl.UINPUT_SYNC}], commands[-2:]) + drawn = frames(commands) + self.assertEqual({"BTN_TOOL_PEN": 1, "ABS_X": 4560, "ABS_Y": 20928, "ABS_PRESSURE": 0, "ABS_DISTANCE": 0, + "ABS_TILT_X": 0, "ABS_TILT_Y": 0}, drawn[0]) + self.assertEqual([{"ABS_X": 4561}, {"BTN_TOUCH": 1, "ABS_X": 4560, "ABS_PRESSURE": 819}], drawn[1:3]) + self.assertEqual([{"ABS_X": 13680, "ABS_PRESSURE": 4095}, {"BTN_TOUCH": 0, "ABS_PRESSURE": 0}, {"ABS_X": 13681}, + {"ABS_X": 13680}, {"BTN_TOOL_PEN": 0}], drawn[-5:]) + pressures = [f["ABS_PRESSURE"] for f in drawn[2:-4]] + self.assertEqual(sorted(pressures), pressures) + + def test_positions_and_tilt_follow_the_rotation(self): + cases = {0: ([1000, 2000], 4000, 24000, 30, -10), 1: ([2000, 1000], 3999, 8000, 10, 30), + 2: ([1000, 2000], 11999, 7999, -30, 10), 3: ([2000, 1000], 12000, 23999, -10, -30)} + for rotation, (size, x, y, tilt_x, tilt_y) in cases.items(): + with self.subTest(rotation=rotation): + self.configure({}, dumpsys_input=dumpsys_input(rotation, size)) + self.log.unlink(missing_ok=True) + code, out = self.pen("tap", "0.25", "0.75", "--tilt-x", "30", "--tilt-y=-10") + self.assertEqual((0, rotation), (code, out["viewport"]["rotation"])) + commands = self.script() + self.assertEqual([15999, 31999], [a["info"]["maximum"] for a in commands[0]["abs_info"][:2]]) + first = frames(commands)[0] + self.assertEqual((x, y, tilt_x, tilt_y), + tuple(first[key] for key in ("ABS_X", "ABS_Y", "ABS_TILT_X", "ABS_TILT_Y"))) + + def test_the_mapping_inverts_aosps_input_coordinates_example(self): + self.assertEqual((0, 2, 0, 0), ctl.uinput_point(2 / 4, 2 / 3, 0, 0, 1, 3, 4, [0, 0, 4, 3])) + self.assertEqual((2, 3, 0, 0), ctl.uinput_point(1, 1, 0, 0, 0, 3, 4, [0, 0, 3, 4])) + self.assertEqual((0, 0, 0, 0), ctl.uinput_point(1, 1, 0, 0, 2, 3, 4, [0, 0, 3, 4])) + + def test_positions_map_onto_the_physical_frame(self): + cases = {0: ((1000, 2000), (100, 250, 900, 1750), ("1", "0.05"), (14399, 5200)), + 1: ((2000, 1000), (250, 100, 1750, 900), ("0.05", "1"), (1600, 5200))} + for rotation, (size, frame, position, first) in cases.items(): + with self.subTest(rotation=rotation): + self.configure({}, dumpsys_input=dumpsys_input(rotation, size, frame=frame)) + self.log.unlink(missing_ok=True) + self.assertEqual(0, self.pen("tap", *position)[0]) + drawn = frames(self.script()) + self.assertEqual(first, (drawn[0]["ABS_X"], drawn[0]["ABS_Y"])) + self.assertTrue(all(1600 <= f.get("ABS_X", 1600) < 14400 for f in drawn)) + + def test_eraser_and_buttons_use_the_stylus_keys(self): + for button, side in (("primary", "BTN_STYLUS"), ("secondary", "BTN_STYLUS2")): + with self.subTest(button=button): + self.log.unlink(missing_ok=True) + code, _ = self.pen("button", button, "0.5", "0.5", "--hold", "40", "--tool", "eraser", "--distance", "12") + self.assertEqual(0, code) + drawn = frames(self.script()) + keys = [(key, value) for frame in drawn for key, value in frame.items() if key.startswith("BTN_")] + self.assertEqual([("BTN_TOOL_RUBBER", 1), (side, 1), (side, 0), ("BTN_TOOL_RUBBER", 0)], keys) + self.assertEqual(12, drawn[0]["ABS_DISTANCE"]) + + def test_a_still_pen_keeps_reporting_at_the_rate(self): + code, out = self.pen("hover", "1", "0.5", "--duration", "100", "--rate", "50") + self.assertEqual(0, code) + commands = self.script() + drawn = frames(commands) + self.assertEqual(out["samples"], len(drawn)) + self.assertEqual([18239, 18238, 18239, 18238, 18239, 18238], [f["ABS_X"] for f in drawn[:-1]]) + self.assertEqual([20, 20, 20, 20, 20, 300], [c["duration"] for c in commands[2:] if c["command"] == "delay"]) + + def test_a_contact_without_pressure_still_touches(self): + code, _ = self.pen("tap", "0.5", "0.5", "--pressure", "0", "--hover-ms", "0", "--hold", "0", "--distance", "5") + self.assertEqual(0, code) + drawn = frames(self.script()) + self.assertEqual((1, 1, 1, 0), + tuple(drawn[0][key] for key in ("BTN_TOOL_PEN", "BTN_TOUCH", "ABS_PRESSURE", "ABS_DISTANCE"))) + self.assertEqual([{"BTN_TOUCH": 0, "ABS_PRESSURE": 0, "ABS_DISTANCE": 5}, {"BTN_TOOL_PEN": 0}], drawn[1:]) + + def test_bad_values_are_refused(self): + cases = [ + (("tap", "1.5", "0.5"), "Positions are fractions of the screen"), + (("hover", "0.5", "0.5", "--to", "nan", "0.5"), "Positions are fractions of the screen"), + (("stroke", "0", "0", "1", "1", "--pressure", "0.5:1.5"), "--pressure must be 0..1"), + (("tap", "0.5", "0.5", "--tilt-x=-91"), "--tilt-x and --tilt-y must be -90..90"), + (("tap", "0.5", "0.5", "--tilt-y", "120"), "--tilt-x and --tilt-y must be -90..90"), + (("hover", "0.5", "0.5", "--distance", "256"), "--distance must be 0..255"), + (("tap", "0.5", "0.5", "--rate", "1e9"), "--rate must be 1..1000 Hz"), + (("button", "primary", "0.5", "0.5", "--hold", "-5"), "--hold must not be negative"), + (("tap", "0.5", "0.5", "--hover-ms", "-1"), "--hover-ms must not be negative"), + (("stroke", "0", "0", "1", "1", "--duration", "40000"), "lasts 40160 ms, more than 30000"), + (("hover", "0.5", "0.5", "--duration", "1000000000"), "more than 30000"), + ] + with unittest.mock.patch.object(ctl, "pen_times", side_effect=AssertionError): + for argv, message in cases: + with self.subTest(message=message): + code, out = self.pen(*argv) + self.assertEqual((2, "INVALID_INPUT"), (code, out["error"]["code"])) + self.assertIn(message, out["error"]["message"]) + self.assertFalse(self.calls()) + self.assertEqual(30_000, samples("tap", "1", "1", "--hover-ms", "14970")[-1]["t"]) + + def test_a_shell_without_uinput_is_unavailable(self): + for probe, message in (("no-uinput", "no `uinput` command"), ("no-dev-uinput", "cannot write /dev/uinput")): + with self.subTest(probe=probe): + self.configure({}, dumpsys_input=dumpsys_input(), uinput_probe=probe) + code, out = self.pen("tap", "0.5", "0.5") + self.assertEqual((3, "UINPUT_UNAVAILABLE"), (code, out["error"]["code"])) + self.assertIn(message, out["error"]["message"]) + self.assertFalse([c for c in self.calls() if c["args"][:2] == ["shell", "uinput"]]) + + def test_a_missing_or_dark_display_is_refused(self): + for dump, message in (("Input Reader State (Nums of device: 0):\n", "no internal display viewport"), + (dumpsys_input(active=0), "Display 0 is off")): + with self.subTest(message=message): + self.configure({}, dumpsys_input=dump) + code, out = self.pen("tap", "0.5", "0.5") + self.assertEqual((3, "NO_VIEWPORT"), (code, out["error"]["code"])) + self.assertIn(message, out["error"]["message"]) + self.assertFalse([c for c in self.calls() if c["args"][:2] == ["shell", "uinput"]]) + + def test_uinput_that_stops_early_fails(self): + self.configure({}, dumpsys_input=dumpsys_input(), uinput_stdout="") + code, out = self.pen("tap", "0.5", "0.5") + self.assertEqual((3, "UINPUT_FAILED"), (code, out["error"]["code"])) + self.assertIn("adb logcat -s UINPUT", out["error"]["message"]) + + def test_the_viewport_android_maps_touchscreens_to(self): + self.assertEqual({"display": 0, "rotation": 0, "size": [1140, 2616], "frame": [0, 0, 1140, 2616], "active": True}, + ctl.input_viewport(dumpsys_input())) + device = " Device 7: touchpanel\n Viewport INTERNAL: displayId=0, orientation=0, deviceSize=[1140, 2616]\n" + self.assertEqual(1, ctl.input_viewport(device + dumpsys_input(1, (2480, 2248)))["rotation"]) + newest = (" Viewports:\n Viewport INTERNAL: displayId=3, uniqueId=local:1, port=, orientation=3, " + "densityDpi=420 xDpi=409.432007, yDpi=411.891998, logicalFrame=[0, 0, 2400, 1080], " + "physicalFrame=[0, 0, 2400, 1080], deviceSize=[2400, 1080], isActive=[1]\n" + " Viewport INTERNAL: displayId=5, uniqueId=local:3, port=2, orientation=0, " + "deviceSize=[1080, 2400], isActive=[1]\n" + " Viewport EXTERNAL: displayId=0, uniqueId=local:2, port=1, orientation=0, " + "deviceSize=[1920, 1080], isActive=[1]\n") + self.assertEqual({"display": 3, "rotation": 3, "size": [2400, 1080], "frame": [0, 0, 2400, 1080], "active": True}, + ctl.input_viewport(newest)) + older = ("Viewport INTERNAL: displayId=0, orientation=2, logicalFrame=[0, 0, 720, 1280], " + "physicalFrame=[-3, 0, 717, 1280], deviceSize=[720, 1280]") + self.assertEqual({"display": 0, "rotation": 2, "size": [720, 1280], "frame": [-3, 0, 717, 1280], "active": True}, + ctl.input_viewport(older)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_esync_packs.py b/tools/tests/test_esync_packs.py index 95ba8ede3a..b7667c5e8e 100644 --- a/tools/tests/test_esync_packs.py +++ b/tools/tests/test_esync_packs.py @@ -1069,26 +1069,36 @@ class LauncherTest(SyncTestCase): dist = self.dist_of(pack["id"], tool) game_env = runpy.run_path(str(BIN / "droiddeck-game-env")) command = [str(tool / "proton"), "waitforexitandrun", "game.exe"] - env = self.env(STEAM_COMPAT_APP_ID="2630", PROTON_NO_NTSYNC="1", BL_SYNC="1", WINEESYNC="1") - calls = [] + cases = ( + ({}, {"WINEDLLOVERRIDES": "tabtip.exe=d"}), + ({"WINEDLLOVERRIDES": "dxgi=n"}, {"WINEDLLOVERRIDES": "dxgi=n;tabtip.exe=d"}), + ({"WINEDLLOVERRIDES": "dxgi=n;tabtip.exe=b"}, {"WINEDLLOVERRIDES": "dxgi=n;tabtip.exe=b"}), + ({"SteamDeck": "1"}, {"SteamDeck": "1"}), + ) + for inherited, expected in cases: + with self.subTest(inherited=inherited): + env = self.env(STEAM_COMPAT_APP_ID="2630", PROTON_NO_NTSYNC="1", BL_SYNC="1", WINEESYNC="1", **inherited) + calls = [] - def execvpe(path, args, environment): - calls.append((path, list(args), dict(environment))) - if len(calls) == 1: - raise PermissionError("denied") - raise SystemExit(0) + def execvpe(path, args, environment): + calls.append((path, list(args), dict(environment))) + if len(calls) == 1: + raise PermissionError("denied") + raise SystemExit(0) - with mock.patch.dict(os.environ, env, clear=True), mock.patch.object(sys, "argv", ["droiddeck-game-env"] + command), \ - mock.patch("os.execvpe", execvpe), contextlib.redirect_stderr(io.StringIO()) as said: - with self.assertRaises(SystemExit): - game_env["main"]() - self.assertEqual([call[:2] for call in calls], [(str(dist / "proton"), [str(dist / "proton")] + command[1:]), - (str(tool / "proton"), command)]) - self.assertEqual((calls[0][2]["WINEESYNC"], calls[0][2]["PROTON_NO_ESYNC"], calls[0][2]["BL_SYNC_PACK"]), ("0", "1", pack["id"])) - self.assertEqual(calls[1][2], self.env(STEAM_COMPAT_APP_ID="2630", PROTON_NO_NTSYNC="1", BL_SYNC="0", WINEESYNC="1", - vblank_mode="0", GAMESCOPE_WSI_MIN_IMAGE_COUNT="8", - GAMESCOPE_WSI_ENSURE_MIN_IMAGE_COUNT="1")) - self.assertIn("could not start (", said.getvalue()) + with mock.patch.dict(os.environ, env, clear=True), mock.patch.object(sys, "argv", ["droiddeck-game-env"] + command), \ + mock.patch("os.execvpe", execvpe), contextlib.redirect_stderr(io.StringIO()) as said: + with self.assertRaises(SystemExit): + game_env["main"]() + self.assertEqual([call[:2] for call in calls], [(str(dist / "proton"), [str(dist / "proton")] + command[1:]), + (str(tool / "proton"), command)]) + self.assertEqual((calls[0][2]["WINEESYNC"], calls[0][2]["PROTON_NO_ESYNC"], calls[0][2]["BL_SYNC_PACK"]), ("0", "1", pack["id"])) + self.assertEqual(calls[1][2], self.env(STEAM_COMPAT_APP_ID="2630", PROTON_NO_NTSYNC="1", BL_SYNC="0", WINEESYNC="1", + vblank_mode="0", GAMESCOPE_WSI_MIN_IMAGE_COUNT="8", + GAMESCOPE_WSI_ENSURE_MIN_IMAGE_COUNT="1", **expected)) + self.assertEqual(calls[0][2].get("WINEDLLOVERRIDES"), expected.get("WINEDLLOVERRIDES")) + self.assertEqual(calls[0][2].get("SteamDeck"), expected.get("SteamDeck")) + self.assertIn("could not start (", said.getvalue()) def test_generated_launchers_run_the_dist_proton(self): root = self.store() diff --git a/tools/tests/test_fakeinput_ring.py b/tools/tests/test_fakeinput_ring.py index 86afc9939a..b032f8ea76 100644 --- a/tools/tests/test_fakeinput_ring.py +++ b/tools/tests/test_fakeinput_ring.py @@ -1,3 +1,5 @@ +import fcntl +import mmap import os from pathlib import Path import shutil @@ -5,6 +7,8 @@ import struct import subprocess import sys import tempfile +import threading +import time import unittest SOURCE = Path(__file__).resolve().parents[2] / "app/src/main/cpp/fakeinput_steam.cpp" @@ -14,6 +18,14 @@ HEADER = 64 EVENT = 24 CAPACITY = 4096 DESCRIPTION = 1824 +RING_SIZE = HEADER + CAPACITY * EVENT +DECK_IMU = 64 +TRITON_BLOCK = 256 +TRITON_MAGIC = 0x4E525454 +TOUCH_MAGIC = 0x31484354 +TOUCH_RING_SIZE = 256 +PAD_TYPE_DECK = 0 +PAD_TYPE_STEAM = 1 READER = r""" #include #include @@ -215,6 +227,72 @@ int main(int argc, char **argv) return 0; } """ +HIDRAW_PROBE = r""" +#include +#include +#include +#include +#include +#include +#include + +int main(int argc, char **argv) +{ + int fd = open(argv[1], O_RDONLY | O_NONBLOCK); + if (fd < 0) { + puts(errno == ENOENT ? "refused" : "failed"); + return 0; + } + struct hidraw_devinfo info; + if (ioctl(fd, HIDIOCGRAWINFO, &info) < 0) + return 1; + struct pollfd ready = {fd, POLLIN, 0}; + unsigned char report[64]; + if (poll(&ready, 1, 2000) != 1 || read(fd, report, sizeof(report)) <= 0) + return 2; + printf("%04hx:%04hx report %02x\n", info.vendor, info.product, report[0]); + return 0; +} +""" +FEATURE_PROBE = r""" +#include +#include +#include +#include +#include + +int main(int argc, char **argv) +{ + unsigned char id = (unsigned char)strtoul(argv[1], NULL, 0); + int fd = open("/dev/hidraw18", O_RDWR); + if (fd < 0) + return 1; + int count = argc > 2 ? atoi(argv[2]) : 200, wrong = 0; + for (int i = 0; i < count; i++) { + unsigned char report[64] = {id}; + if (ioctl(fd, HIDIOCGFEATURE(sizeof(report)), report) < 0 || report[0] != id || report[1] != id) + wrong++; + } + printf("%d wrong\n", wrong); + return 0; +} +""" +IMU_MODE_PROBE = r""" +#include +#include +#include +#include + +int main(int argc, char **argv) +{ + unsigned mode = (unsigned)strtoul(argv[1], NULL, 0); + int fd = open("/dev/hidraw16", O_RDWR); + if (fd < 0) + return 1; + unsigned char report[65] = {0x00, 0x87, 3, 48, mode & 0xff, mode >> 8}; + return ioctl(fd, HIDIOCSFEATURE(sizeof(report)), report) < 0; +} +""" OVERLAY_READ = r""" #include #include @@ -348,6 +426,117 @@ class FakeinputRingTest(unittest.TestCase): self.assertEqual(run.returncode, 0, run.stderr) self.assertEqual(run.stdout, "JSIOCGNAME -1 EINVAL\n28de:11ff Microsoft X-Box 360 pad 0\n") + def pad_ring(self, pad_type, triton_connected=False): + hooks, ring = self.ring(virtual=False) + data = bytearray(ring.read_bytes()) + bytearray(DECK_IMU + TRITON_BLOCK) + struct.pack_into(" +#include +#include +#include +#include +#include + +static int rumble(int fd, unsigned short strong) { + struct ff_effect effect; + memset(&effect, 0, sizeof(effect)); + effect.id = -1; + effect.type = FF_RUMBLE; + effect.u.rumble.strong_magnitude = strong; + effect.u.rumble.weak_magnitude = 20000; + if (ioctl(fd, EVIOCSFF, &effect) < 0) return -1; + struct input_event play; + memset(&play, 0, sizeof(play)); + play.type = EV_FF; + play.code = effect.id; + play.value = 1; + if (write(fd, &play, sizeof(play)) != sizeof(play)) return -1; + return effect.id; +} + +int main(int argc, char **argv) { + int fd = open("/dev/input/event16", O_RDWR | O_NONBLOCK); + if (fd < 0) return 1; + if (argv[1][0] == 'p') { + int other = open("/dev/input/event16", O_RDWR | O_NONBLOCK); + if (other < 0 || rumble(fd, 40000) < 0 || rumble(other, 30000) < 0) return 2; + close(fd); + return 0; + } + if (argv[1][0] == 'k') { + pid_t child = fork(); + if (child == 0) { + if (rumble(fd, 40000) < 0) _exit(2); + close(fd); + _exit(0); + } + int status = 0; + waitpid(child, &status, 0); + return WEXITSTATUS(status); + } + struct ff_effect effect; + effect.id = rumble(fd, 40000); + if (effect.id < 0) return 2; + if (argv[1][0] == 'e') ioctl(fd, EVIOCRMFF, effect.id); + else if (argv[1][0] == 'c') close(fd); + else if (argv[1][0] == 'f') { + pid_t child = fork(); + if (child == 0) { + close(fd); + _exit(0); + } + waitpid(child, NULL, 0); + } + return 0; +} +""" + + +@unittest.skipUnless(sys.platform == "linux" and shutil.which("g++") and shutil.which("gcc"), "needs Linux, gcc and g++") +class FakeinputRumbleStopTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.tmp = Path(tempfile.mkdtemp()) + cls.addClassCleanup(shutil.rmtree, cls.tmp, True) + cls.library = cls.tmp / "libfakeinput.so" + subprocess.run(["g++", "-shared", "-fPIC", "-O2", "-Wno-attributes", "-pthread", "-std=c++17", + "-static-libstdc++", "-static-libgcc", "-Wl,--exclude-libs,ALL", "-o", str(cls.library), + str(SOURCE), "-ldl"], check=True) + cls.game = cls.tmp / "game" + (cls.tmp / "game.c").write_text(GAME) + subprocess.run(["gcc", "-o", str(cls.game), str(cls.tmp / "game.c")], check=True) + cls.hooks = cls.tmp / "hooks" + cls.hooks.mkdir() + (cls.hooks / "event16").touch() + ring = bytearray(HEADER + CAPACITY * EVENT + DESCRIPTION) + struct.pack_into("") + return path + + def read_tail(self, path): + with open(path, "rb") as game: + game.seek(MODULE["DS_WINDOW_OFFSET"] - 1) + return game.read(len(MODULE["DS_WINDOW"]) + len(MODULE["DS_ORIGINAL"]) + 2) + + def run_fix(self, path, app_id="1850570"): + errors = io.StringIO() + with mock.patch("sys.stderr", errors): + return MODULE["death_stranding_allocator"](app_id, path), errors.getvalue() + + def test_window_and_patch_have_the_measured_shape(self): + self.assertEqual(41, len(MODULE["DS_WINDOW"])) + self.assertEqual(6, len(MODULE["DS_ORIGINAL"])) + self.assertEqual(6, len(MODULE["DS_FIXED"])) + self.assertEqual(0x38FE1B9, MODULE["DS_WINDOW_OFFSET"] + len(MODULE["DS_WINDOW"])) + + def test_replaces_only_the_jump_in_the_original_build(self): + path = self.make_exe() + patched, message = self.run_fix(path) + self.assertTrue(patched) + self.assertIn("Death Stranding", message) + self.assertEqual(b"<" + MODULE["DS_WINDOW"] + MODULE["DS_FIXED"] + b">", self.read_tail(path)) + self.assertEqual(MODULE["DS_SIZE"], os.path.getsize(path)) + + def test_an_already_patched_game_is_left_alone(self): + path = self.make_exe(tail=MODULE["DS_FIXED"]) + before = os.stat(path).st_mtime_ns + self.assertEqual((False, ""), self.run_fix(path)) + self.assertEqual(before, os.stat(path).st_mtime_ns) + self.assertEqual(b"<" + MODULE["DS_WINDOW"] + MODULE["DS_FIXED"] + b">", self.read_tail(path)) + + def test_a_second_run_changes_nothing(self): + path = self.make_exe() + self.assertTrue(self.run_fix(path)[0]) + after_first = self.read_tail(path) + self.assertEqual((False, ""), self.run_fix(path)) + self.assertEqual(after_first, self.read_tail(path)) + + def test_other_builds_of_the_game_are_not_touched(self): + for size, window in ((MODULE["DS_SIZE"] + 1, None), (None, bytes(len(MODULE["DS_WINDOW"])))): + path = self.make_exe(size=size, window=window) + before = self.read_tail(path) + self.assertEqual((False, ""), self.run_fix(path)) + self.assertEqual(before, self.read_tail(path)) + + def test_an_unknown_instruction_at_the_patch_site_is_not_touched(self): + path = self.make_exe(tail=bytes.fromhex("0f85a6000000")) + before = self.read_tail(path) + self.assertEqual((False, ""), self.run_fix(path)) + self.assertEqual(before, self.read_tail(path)) + + def test_other_executables_are_ignored(self): + path = self.make_exe(name="game.exe") + before = self.read_tail(path) + self.assertEqual((False, ""), self.run_fix(path)) + self.assertEqual(before, self.read_tail(path)) + + def test_other_games_are_not_touched_even_with_a_matching_file(self): + for app_id in ("440", "", None): + path = self.make_exe() + before = self.read_tail(path) + self.assertEqual((False, ""), self.run_fix(path, app_id)) + self.assertEqual(before, self.read_tail(path)) + + def test_both_death_stranding_app_ids_are_patched(self): + for app_id in ("1850570", "1190460"): + self.assertTrue(self.run_fix(self.make_exe(), app_id)[0]) + + def test_the_file_name_check_ignores_case(self): + self.assertTrue(self.run_fix(self.make_exe(name="DS.EXE"))[0]) + + def test_a_missing_game_file_is_reported_without_raising(self): + patched, message = self.run_fix(os.path.join(tempfile.gettempdir(), "droiddeck-no-such-folder", "ds.exe")) + self.assertFalse(patched) + self.assertIn("not applied", message) + + def mapping_of(text): tokens = COMPAT["tokenize"](text) return COMPAT["read_mapping"](tokens, COMPAT["mapping_block"](tokens)) @@ -723,6 +811,7 @@ class GameEnvironmentTest(unittest.TestCase): "install_scripts_done": lambda scripts, env: False, "scripts_digest": lambda scripts: None, "win_components": lambda *args: seen_components.append(args[3]) or "", + "restore_compatible_system_dlls": lambda *args: [], "repair_foreign_system_dlls": lambda *args: seen_repair.append(args[2]) or [], "gl_vsync": lambda env: False, "game_images": lambda env: None, @@ -756,6 +845,61 @@ class GameEnvironmentTest(unittest.TestCase): self.assertEqual(["0"], [env["PROTON_USE_ARM64"] for env in seen_repair]) self.assertEqual(["0"], [env["PROTON_USE_ARM64"] for env in seen_start]) + def test_keyboard_helper_is_off_unless_steam_keyboard_or_the_user_wants_it(self): + cases = ( + ({}, "tabtip.exe=d"), + ({"WINEDLLOVERRIDES": "dxgi=n"}, "dxgi=n;tabtip.exe=d"), + ({"WINEDLLOVERRIDES": "tabtipx=d"}, "tabtipx=d;tabtip.exe=d"), + ({"SteamDeck": "0"}, "tabtip.exe=d"), + ({"SteamDeck": "1"}, None), + ({"SteamDeck": "1", "WINEDLLOVERRIDES": "dxgi=n"}, "dxgi=n"), + ({"WINEDLLOVERRIDES": "tabtip.exe=b"}, "tabtip.exe=b"), + ({"WINEDLLOVERRIDES": "dxgi=n; TabTip.EXE=n,b"}, "dxgi=n; TabTip.EXE=n,b"), + ({"WINEDLLOVERRIDES": "dxgi=n; TabTip=n,b"}, "dxgi=n; TabTip=n,b;tabtip.exe=d"), + ({"WINEDLLOVERRIDES": "d3d11 tabtip.exe"}, "d3d11 tabtip.exe;tabtip.exe=d"), + ({"WINEDLLOVERRIDES": "tabtip.exe;dxgi=n"}, "tabtip.exe;dxgi=n;tabtip.exe=d"), + ({"WINEDLLOVERRIDES": "d3d11,tabtip.exe=b"}, "d3d11,tabtip.exe=b"), + ({"WINEDLLOVERRIDES": "d3d11 tabtip.exe=b"}, "d3d11 tabtip.exe=b"), + ({"WINEDLLOVERRIDES": "d3d11\ttabtip.exe=b"}, "d3d11\ttabtip.exe=b"), + ({"WINEDLLOVERRIDES": "d3d11\ttabtip=b"}, "d3d11\ttabtip=b;tabtip.exe=d"), + ({"WINEDLLOVERRIDES": "d3d11 dxgi=n"}, "d3d11 dxgi=n;tabtip.exe=d"), + ({"WINEDLLOVERRIDES": "*tabtip.exe=b"}, "*tabtip.exe=b"), + ({"WINEDLLOVERRIDES": "TabTip.exe.DLL=b"}, "TabTip.exe.DLL=b"), + ({"WINEDLLOVERRIDES": "d3d11,*tabtip.exe.dll=n"}, "d3d11,*tabtip.exe.dll=n"), + ({"WINEDLLOVERRIDES": "*tabtip=b"}, "*tabtip=b;tabtip.exe=d"), + ({"WINEDLLOVERRIDES": "tabtip.dll=b"}, "tabtip.dll=b;tabtip.exe=d"), + ) + for before, overrides in cases: + with self.subTest(env=before): + env = dict(before) + note = MODULE["keyboard_helper_off"](env) + self.assertEqual(env.get("WINEDLLOVERRIDES"), overrides) + self.assertEqual(note is not None, overrides != before.get("WINEDLLOVERRIDES")) + + def test_game_launch_turns_the_keyboard_helper_off_and_keeps_user_choices(self): + with tempfile.TemporaryDirectory() as tmp: + home = Path(tmp) + probe = home / "probe" + probe.write_text("#!" + sys.executable + "\nimport os\nprint(os.environ.get('WINEDLLOVERRIDES', 'unset'))\n") + probe.chmod(0o755) + config = home / ".config/droiddeck/game-environment.json" + config.parent.mkdir(parents=True) + cases = ( + ("waitforexitandrun", {}, "tabtip.exe=d"), + ("waitforexitandrun", {"WINEDLLOVERRIDES": "dxgi=n"}, "dxgi=n;tabtip.exe=d"), + ("waitforexitandrun", {"SteamDeck": "1"}, "unset"), + ("waitforexitandrun", {"WINEDLLOVERRIDES": "tabtip.exe=b"}, "tabtip.exe=b"), + ("run", {}, "unset"), + ) + for verb, profile, expected in cases: + with self.subTest(verb=verb, profile=profile): + config.write_text(json.dumps({"version": 1, "games": {"42": profile}})) + env = {k: v for k, v in os.environ.items() if k not in ("SteamDeck", "WINEDLLOVERRIDES")} + env.update(HOME=tmp, STEAM_COMPAT_DATA_PATH="/compatdata/42") + result = subprocess.run([sys.executable, str(BIN / "droiddeck-game-env"), str(probe), verb], + env=env, text=True, capture_output=True, check=True) + self.assertEqual(result.stdout.strip().splitlines()[-1], expected) + def test_optional_xbox_loader_failure_keeps_stock_launch(self): from unittest.mock import patch for error in (FileNotFoundError('missing'), RuntimeError('module initialization failed')): @@ -1172,6 +1316,8 @@ class GameEnvironmentTest(unittest.TestCase): self.assertEqual(env["WINEDLLOVERRIDES"], "libsentry.windows.release.x86_64=d") self.assertEqual(extra, ["--rendering-driver", "vulkan"]) self.assertEqual(MODULE["engine_fixes"](str(game / "Game.exe"), ["--rendering-driver", "opengl3"])[1], []) + (game / "data_game_windows_x86_64/Sentry.Godot.dll").touch() + self.assertNotIn("WINEDLLOVERRIDES", MODULE["engine_fixes"](str(game / "Game.exe"), [])[0]) script = Path(tmp) / "GDScript Game" script.mkdir() for name in ("Game.exe", "Game.pck", "libsentry.windows.release.x86_64.dll"): @@ -1592,6 +1738,35 @@ class GameEnvironmentTest(unittest.TestCase): self.assertEqual(result["FEX_TSOENABLED"], "0") self.assertEqual(result["WINEDLLOVERRIDES"], "dxgi=n;libsentry=d") + def test_game_dll_overrides_follow_droiddecks_own(self): + fixes = {"WINEDLLOVERRIDES": "msvcp100=n,b"} + config = {"version": 1, "shared": {}, "games": {"42": {"WINEDLLOVERRIDES": "windowscodecs,windowscodecsext=n"}}} + result = MODULE["apply_config"]({}, config, "42", fixes) + self.assertEqual(result["WINEDLLOVERRIDES"], "msvcp100=n,b;windowscodecs,windowscodecsext=n") + + def test_game_dll_overrides_edge_cases(self): + fixes = {"WINEDLLOVERRIDES": "msvcp100=n,b"} + env = {"WINEDLLOVERRIDES": "dxgi=n"} + for game, shared, expected in ( + ({"WINEDLLOVERRIDES": "msvcp100=b"}, {}, "msvcp100=n,b;msvcp100=b"), + ({"WINEDLLOVERRIDES": ""}, {}, "msvcp100=n,b"), + ({"WINEDLLOVERRIDES": None}, {}, None), + ({"WINEDLLOVERRIDES": "d3d9=n"}, {"WINEDLLOVERRIDES": "xinput1_3=n"}, "msvcp100=n,b;d3d9=n"), + ({}, {}, "dxgi=n;msvcp100=n,b"), + ({"WINEDLLOVERRIDES": "x" * 8179}, {}, "msvcp100=n,b;" + "x" * 8179), + ): + with self.subTest(game=game, shared=shared): + config = {"version": 1, "shared": shared, "games": {"42": game, "43": {"WINEDLLOVERRIDES": "d3d11=n"}}} + result = MODULE["apply_config"](env, config, "42", fixes) + self.assertEqual(result.get("WINEDLLOVERRIDES"), expected) + self.assertEqual(MODULE["apply_config"](env, config, "43")["WINEDLLOVERRIDES"], "d3d11=n") + stderr = io.StringIO() + config = {"version": 1, "shared": {}, "games": {"42": {"WINEDLLOVERRIDES": "x" * 8192}}} + with mock.patch("sys.stderr", stderr): + result = MODULE["apply_config"](env, config, "42", fixes) + self.assertEqual(result["WINEDLLOVERRIDES"], "x" * 8192) + self.assertIn("too long", stderr.getvalue()) + def test_invalid_configuration_is_atomic(self): env = {"ORIGINAL": "unchanged"} for entries in ({"A": "ok", "BAD=KEY": "x"}, {"A": "bad\0value"}, {"A": 1}): @@ -2718,6 +2893,39 @@ def arm64ec_pe_image(): return bytes(image) +def program_image(machine, imports): + image = bytearray(0x400) + image[:2] = b"MZ" + image[60:64] = (64).to_bytes(4, "little") + image[64:68] = b"PE\0\0" + coff = 68 + image[coff:coff + 2] = machine.to_bytes(2, "little") + image[coff + 2:coff + 4] = (1).to_bytes(2, "little") + image[coff + 16:coff + 18] = (240).to_bytes(2, "little") + optional = coff + 20 + image[optional:optional + 2] = (0x20B).to_bytes(2, "little") + image[optional + 108:optional + 112] = (16).to_bytes(4, "little") + image[optional + 120:optional + 124] = (0x1000).to_bytes(4, "little") + image[optional + 124:optional + 128] = (20 * (len(imports) + 1)).to_bytes(4, "little") + section = optional + 240 + image[section + 8:section + 12] = (0x200).to_bytes(4, "little") + image[section + 12:section + 16] = (0x1000).to_bytes(4, "little") + image[section + 16:section + 20] = (0x200).to_bytes(4, "little") + image[section + 20:section + 24] = (0x200).to_bytes(4, "little") + name = 20 * (len(imports) + 1) + for index, dll in enumerate(imports): + image[0x200 + index * 20 + 12:0x200 + index * 20 + 16] = (0x1000 + name).to_bytes(4, "little") + image[0x200 + name:0x200 + name + len(dll)] = dll.encode() + name += len(dll) + 1 + return bytes(image) + + +def bytes_path(folder, data): + path = folder / "image.exe" + path.write_bytes(data) + return path + + class ForeignSystemDllTest(unittest.TestCase): def prefix(self, tmp, arm=True): proton = Path(tmp) / "Proton" @@ -2729,7 +2937,8 @@ class ForeignSystemDllTest(unittest.TestCase): for libdir, machine in (("aarch64-windows", 0xAA64), ("i386-windows", 0x14C)): (dist / libdir).mkdir(parents=True) for name in ("ucrtbase.dll", "rpcrt4.dll"): - (dist / libdir / name).write_bytes(pe_image(machine)) + (dist / libdir / name).write_bytes(program_image(machine, [])) + (dist / "aarch64-windows/wineboot.exe").write_bytes(program_image(0xAA64, ["UCRTBASE.dll", "rpcrt4.dll"])) windows = Path(tmp) / "compat/pfx/drive_c/windows" for folder in ("system32", "syswow64"): (windows / folder).mkdir(parents=True) @@ -2769,16 +2978,148 @@ class ForeignSystemDllTest(unittest.TestCase): self.assertFalse((system32 / "ucrtbase.dll").is_symlink()) self.assertEqual(0x8664, MODULE["pe_machine"](system32 / "userlib.dll")) - def test_x64_visual_cpp_runtime_in_arm64_system32_is_kept(self): + def test_x64_dlls_proton_programs_do_not_import_are_kept_in_arm64_system32(self): with tempfile.TemporaryDirectory() as tmp: proton, compat, windows = self.prefix(tmp) builtins = proton.parent / "files/lib/wine/aarch64-windows" - for name in ("msvcp140.dll", "VCRUNTIME140.dll", "msvcp_win.dll"): - (builtins / name.lower()).write_bytes(pe_image(0xAA64)) + (builtins / "explorer.exe").write_bytes(program_image(0xAA64, ["shell32.dll"])) + (builtins / "shell32.dll").write_bytes(program_image(0xAA64, ["msvcp_win.dll"])) + names = ("vulkan-1.dll", "msvcp140.dll", "VCRUNTIME140.dll", "concrt140.dll", "d3dcompiler_43.dll", + "winhttp.dll", "msvcp_win.dll") + for name in names: + (builtins / name.lower()).write_bytes(program_image(0xAA64, [])) (windows / "system32" / name).write_bytes(pe_image(0x8664)) self.assertEqual(["system32/msvcp_win.dll (machine 0x8664)"], self.run_repair(compat, proton)) - self.assertFalse((windows / "system32/msvcp140.dll").is_symlink()) - self.assertFalse((windows / "system32/VCRUNTIME140.dll").is_symlink()) + for name in names[:-1]: + self.assertFalse((windows / "system32" / name).is_symlink()) + self.assertEqual(0x8664, MODULE["pe_machine"](windows / "system32" / name)) + + def test_repaired_dll_proton_programs_do_not_import_gets_its_native_copy_back(self): + with tempfile.TemporaryDirectory() as tmp: + proton, compat, windows = self.prefix(tmp) + builtins = proton.parent / "files/lib/wine/aarch64-windows" + (builtins / "vulkan-1.dll").write_bytes(pe_image(0xAA64)) + system32 = windows / "system32" + for name in ("vulkan-1.dll", "ucrtbase.dll"): + (system32 / name).symlink_to(os.path.relpath(builtins / name, system32)) + (system32 / (name + ".foreign-arch")).write_bytes(pe_image(0x8664)) + (system32 / "vulkan-1.dll.foreign-arch.1").write_bytes(pe_image(0x8664) + b"newest") + restore = MODULE["restore_compatible_system_dlls"] + self.assertEqual(["system32/vulkan-1.dll (machine 0x8664)"], restore(str(compat), str(proton))) + self.assertFalse((system32 / "vulkan-1.dll").is_symlink()) + self.assertTrue((system32 / "vulkan-1.dll").read_bytes().endswith(b"newest")) + self.assertFalse((system32 / "vulkan-1.dll.foreign-arch.1").exists()) + self.assertTrue((system32 / "ucrtbase.dll").is_symlink()) + self.assertEqual([], restore(str(compat), str(proton))) + self.assertEqual([], self.run_repair(compat, proton)) + + def test_prefix_backup_directory_is_listed_once_per_pass(self): + with tempfile.TemporaryDirectory() as tmp: + proton, compat, windows = self.prefix(tmp) + builtins = proton.parent / "files/lib/wine/aarch64-windows" + system32 = windows / "system32" + for index in range(12): + name = "native_%02d.dll" % index + (builtins / name).write_bytes(pe_image(0xAA64)) + (system32 / name).symlink_to(os.path.relpath(builtins / name, system32)) + (system32 / (name + ".foreign-arch")).write_bytes(pe_image(0x8664)) + (system32 / "ucrtbase.dll").write_bytes(pe_image(0x8664)) + original_listdir = os.listdir + visited = [] + + def counted_listdir(folder): + if Path(folder) == system32: + visited.append(folder) + return original_listdir(folder) + + with mock.patch("os.listdir", side_effect=counted_listdir): + restored = MODULE["restore_compatible_system_dlls"](str(compat), str(proton)) + fixed = self.run_repair(compat, proton) + self.assertEqual(12, len(restored)) + self.assertEqual(["system32/ucrtbase.dll (machine 0x8664)"], fixed) + # One system32 listing for restore and one for repair, regardless + # of the number of DLLs and backup files in the prefix. + self.assertEqual(2, len(visited)) + + def test_restore_takes_the_highest_backup_serial_across_gaps(self): + with tempfile.TemporaryDirectory() as tmp: + proton, compat, windows = self.prefix(tmp) + builtins = proton.parent / "files/lib/wine/aarch64-windows" + (builtins / "vulkan-1.dll").write_bytes(pe_image(0xAA64)) + system32 = windows / "system32" + (system32 / "vulkan-1.dll").symlink_to(os.path.relpath(builtins / "vulkan-1.dll", system32)) + (system32 / "vulkan-1.dll.foreign-arch.2").write_bytes(pe_image(0x8664) + b"two") + (system32 / "vulkan-1.dll.foreign-arch.10").write_bytes(pe_image(0x8664) + b"ten") + self.assertEqual(["system32/vulkan-1.dll (machine 0x8664)"], + MODULE["restore_compatible_system_dlls"](str(compat), str(proton))) + self.assertTrue((system32 / "vulkan-1.dll").read_bytes().endswith(b"ten")) + + def test_unreadable_proton_program_keeps_the_conservative_rule(self): + with tempfile.TemporaryDirectory() as tmp: + proton, compat, windows = self.prefix(tmp) + builtins = proton.parent / "files/lib/wine/aarch64-windows" + (builtins / "broken.exe").mkdir() + (builtins / "vulkan-1.dll").write_bytes(pe_image(0xAA64)) + system32 = windows / "system32" + (system32 / "concrt140.dll").write_bytes(pe_image(0x8664)) + (builtins / "concrt140.dll").write_bytes(pe_image(0xAA64)) + (system32 / "vulkan-1.dll").symlink_to(os.path.relpath(builtins / "vulkan-1.dll", system32)) + (system32 / "vulkan-1.dll.foreign-arch").write_bytes(pe_image(0x8664)) + self.assertEqual([], MODULE["restore_compatible_system_dlls"](str(compat), str(proton))) + self.assertTrue((system32 / "vulkan-1.dll").is_symlink()) + self.assertEqual(["system32/concrt140.dll (machine 0x8664)"], self.run_repair(compat, proton)) + + def test_new_backup_goes_above_the_highest_existing_serial(self): + with tempfile.TemporaryDirectory() as tmp: + proton, compat, windows = self.prefix(tmp) + system32 = windows / "system32" + (system32 / "ucrtbase.dll").write_bytes(pe_image(0x8664) + b"newest") + (system32 / "ucrtbase.dll.foreign-arch").write_bytes(pe_image(0x8664)) + (system32 / "ucrtbase.dll.foreign-arch.2").write_bytes(pe_image(0x8664)) + self.assertEqual(["system32/ucrtbase.dll (machine 0x8664)"], self.run_repair(compat, proton)) + self.assertTrue((system32 / "ucrtbase.dll.foreign-arch.3").read_bytes().endswith(b"newest")) + self.assertFalse((system32 / "ucrtbase.dll.foreign-arch.1").exists()) + + def test_truncated_import_table_keeps_the_conservative_rule(self): + with tempfile.TemporaryDirectory() as tmp: + proton, compat, windows = self.prefix(tmp) + builtins = proton.parent / "files/lib/wine/aarch64-windows" + (builtins / "cut.exe").write_bytes(program_image(0xAA64, ["concrt140.dll"])[:0x20A]) + self.assertIsNone(MODULE["PE"]["pe_imports"](builtins / "cut.exe")) + self.assertIsNone(MODULE["PE"]["pe_imports"](bytes_path(Path(tmp), program_image(0xAA64, ["a.dll"])[:200]))) + self.assertEqual(set(), MODULE["PE"]["pe_imports"](bytes_path(Path(tmp), program_image(0xAA64, [])))) + moved = bytearray(program_image(0xAA64, ["concrt140.dll"])) + moved[208:212] = (0x3000).to_bytes(4, "little") + self.assertIsNone(MODULE["PE"]["pe_imports"](bytes_path(Path(tmp), moved))) + (builtins / "concrt140.dll").write_bytes(pe_image(0xAA64)) + (windows / "system32/concrt140.dll").write_bytes(pe_image(0x8664)) + self.assertEqual(["system32/concrt140.dll (machine 0x8664)"], self.run_repair(compat, proton)) + + def test_restore_leaves_other_links_and_x64_proton_alone(self): + with tempfile.TemporaryDirectory() as tmp: + proton, compat, windows = self.prefix(tmp) + builtins = proton.parent / "files/lib/wine/aarch64-windows" + (builtins / "vulkan-1.dll").write_bytes(pe_image(0xAA64)) + other = Path(tmp) / "other-vulkan-1.dll" + other.write_bytes(pe_image(0xAA64)) + system32 = windows / "system32" + (system32 / "vulkan-1.dll").symlink_to(other) + (system32 / "vulkan-1.dll.foreign-arch").write_bytes(pe_image(0x8664)) + (system32 / "rpcrt4.dll").symlink_to(os.path.relpath(builtins / "rpcrt4.dll", system32)) + (system32 / "rpcrt4.dll.foreign-arch").write_bytes(pe_image(0x14C)) + self.assertEqual([], MODULE["restore_compatible_system_dlls"](str(compat), str(proton))) + self.assertTrue((system32 / "vulkan-1.dll").is_symlink()) + self.assertTrue((system32 / "rpcrt4.dll").is_symlink()) + with tempfile.TemporaryDirectory() as tmp: + proton, compat, windows = self.prefix(tmp, arm=False) + dist = proton.parent / "files/lib/wine/x86_64-windows" + dist.mkdir(parents=True) + (dist / "vulkan-1.dll").write_bytes(pe_image(0x8664)) + system32 = windows / "system32" + (system32 / "vulkan-1.dll").symlink_to(os.path.relpath(dist / "vulkan-1.dll", system32)) + (system32 / "vulkan-1.dll.foreign-arch").write_bytes(pe_image(0xAA64)) + self.assertEqual([], MODULE["restore_compatible_system_dlls"](str(compat), str(proton))) + self.assertTrue((system32 / "vulkan-1.dll").is_symlink()) def test_final_arm64ec_image_is_not_repaired_as_a_foreign_x64_dll(self): with tempfile.TemporaryDirectory() as tmp: diff --git a/tools/tests/test_gamescope_touch_click.py b/tools/tests/test_gamescope_touch_click.py new file mode 100644 index 0000000000..f985d3ff27 --- /dev/null +++ b/tools/tests/test_gamescope_touch_click.py @@ -0,0 +1,112 @@ +from pathlib import Path +import shutil +import subprocess +import tempfile +import unittest + + +ROOT = Path(__file__).resolve().parents[2] +PATCH = ROOT / "tools/gamescope/patches/0134-touch-click-press-once.patch" + + +def added_source(): + return "\n".join(line[1:] for line in PATCH.read_text().splitlines() if line.startswith("+") and not line.startswith("+++")) + + +def block(text, start): + begin = text.index(start) + return text[begin:text.index("\n}", begin) + 3] + + +PREAMBLE = r''' +#include +#include +#define WLSERVER_BUTTON_COUNT 7 +enum { HOVER = 0, LEFT = 1, RIGHT = 2, PASSTHROUGH = 4 }; +static const uint32_t BTN_L = 0x110, BTN_R = 0x111; +''' + +MAIN = r''' +struct Seat { + int pressed[2] = {0, 0}; + int sent[2] = {0, 0}; + int slot(uint32_t b) { return b == BTN_L ? 0 : 1; } + void press(uint32_t b) { if (pressed[slot(b)]++ == 0) sent[slot(b)]++; } + void release(uint32_t b) { if (pressed[slot(b)] > 0 && --pressed[slot(b)] == 0) sent[slot(b)]--; } +}; + +static uint32_t button_of(int mode) { return mode == LEFT ? BTN_L : mode == RIGHT ? BTN_R : 0; } + +struct Server { + bool held[WLSERVER_BUTTON_COUNT] = {}; + Seat seat; + void down(int mode) { + uint32_t b = button_of(mode); + if (touch_click_press(held, mode, b)) seat.press(b); + } + void up() { + for (int i = 0; i < WLSERVER_BUTTON_COUNT; i++) { + if (held[i] && button_of(i)) seat.release(button_of(i)); + held[i] = false; + } + } +}; + +int main() { + Server tap; + tap.down(LEFT); + assert(tap.seat.sent[0] == 1); + tap.up(); + assert(tap.seat.sent[0] == 0 && tap.seat.pressed[0] == 0); + + Server overlap; + overlap.down(LEFT); + overlap.down(LEFT); + overlap.up(); + overlap.up(); + assert(overlap.seat.pressed[0] == 0 && overlap.seat.sent[0] == 0); + overlap.down(LEFT); + assert(overlap.seat.sent[0] == 1); + overlap.up(); + assert(overlap.seat.sent[0] == 0); + + Server three; + for (int i = 0; i < 3; i++) three.down(LEFT); + for (int i = 0; i < 3; i++) three.up(); + assert(three.seat.pressed[0] == 0); + + Server modes; + modes.down(LEFT); + modes.down(RIGHT); + modes.up(); + modes.up(); + assert(modes.seat.pressed[0] == 0 && modes.seat.pressed[1] == 0); + + Server hover; + hover.down(HOVER); + hover.down(PASSTHROUGH); + assert(hover.seat.pressed[0] == 0 && hover.seat.pressed[1] == 0); + bool held[WLSERVER_BUTTON_COUNT] = {}; + assert(!touch_click_press(held, -1, BTN_L)); + assert(!touch_click_press(held, WLSERVER_BUTTON_COUNT, BTN_L)); + return 0; +} +''' + + +class GamescopeTouchClickTest(unittest.TestCase): + def test_overlapping_touches_release_the_emulated_button(self): + compiler = shutil.which("c++") or shutil.which("g++") or shutil.which("clang++") + if not compiler: + self.skipTest("no C++ compiler") + source = PREAMBLE + block(added_source(), "static bool touch_click_press") + MAIN + with tempfile.TemporaryDirectory() as tmp: + src = Path(tmp) / "touch_click.cpp" + exe = Path(tmp) / "touch_click" + src.write_text(source) + subprocess.run([compiler, "-std=c++17", "-Wall", "-Werror", "-UNDEBUG", str(src), "-o", str(exe)], check=True) + subprocess.run([str(exe)], check=True) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_mali_compat_layer.py b/tools/tests/test_mali_compat_layer.py new file mode 100644 index 0000000000..fb0b21f5ea --- /dev/null +++ b/tools/tests/test_mali_compat_layer.py @@ -0,0 +1,56 @@ +import os +from pathlib import Path +import shutil +import subprocess +import tempfile +import unittest + + +ROOT = Path(__file__).resolve().parents[2] +LAYER = ROOT / "tools/venus/layer" +DEPS = ROOT / "build/layer-deps" + + +def include(variable, default): + return Path(os.environ.get(variable, str(default))) + + +class MaliCompatLayerTest(unittest.TestCase): + def test_dual_source_blending_against_a_mock_loader_and_driver(self): + compiler = shutil.which(os.environ.get("CC", "cc")) + if not compiler: + self.fail("A C compiler is required for the Mali compatibility layer test") + vulkan = include("MALI_COMPAT_VULKAN_INCLUDE", DEPS / "vulkan/include") + spirv = include("MALI_COMPAT_SPIRV_INCLUDE", DEPS / "spirv/include") + bcdec = include("MALI_COMPAT_BCDEC_INCLUDE", DEPS / "bcdec") + missing = [str(path) for path in (vulkan / "vulkan/vk_layer.h", spirv / "spirv/unified1/spirv.h", + bcdec / "bcdec.h") if not path.is_file()] + if missing: + message = "Vulkan 1.4, SPIR-V and bcdec headers are required: " + ", ".join(missing) + if os.environ.get("CI"): + self.fail(message) + self.skipTest(message) + with tempfile.TemporaryDirectory(prefix="droiddeck-mali-compat-") as tmp: + program = Path(tmp) / "mali-compat-layer" + built = subprocess.run([compiler, "-std=gnu11", "-Wall", "-Wextra", "-Werror", "-Wno-unused-parameter", + "-UNDEBUG", "-pthread", "-I", str(LAYER), "-I", str(vulkan), "-I", str(spirv), + "-I", str(bcdec), str(Path(__file__).with_name("mali_compat_layer_test.c")), + *sorted(str(source) for source in LAYER.glob("*.c")), "-o", str(program)], + capture_output=True, text=True) + self.assertEqual(built.returncode, 0, built.stdout + built.stderr) + ran = subprocess.run([str(program), tmp], capture_output=True, text=True, timeout=30) + self.assertEqual(ran.returncode, 0, ran.stdout + ran.stderr) + self.assertIn("mali compat layer ok", ran.stdout) + self.assertIn("emulating dualSrcBlend for mock", ran.stderr) + validator = shutil.which("spirv-val") + if not validator: + return + for name, environment in (("dual-1.0.spv", "vulkan1.0"), ("plain-1.0.spv", "vulkan1.0"), + ("stripped-1.0.spv", "vulkan1.0"), ("stripped-1.4.spv", "vulkan1.2")): + checked = subprocess.run([validator, "--target-env", environment, str(Path(tmp) / name)], + capture_output=True, text=True) + self.assertEqual(checked.returncode, 0, name + ": " + checked.stdout + checked.stderr) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_memory_pressure.py b/tools/tests/test_memory_pressure.py index 01c32c3f82..29a2008866 100644 --- a/tools/tests/test_memory_pressure.py +++ b/tools/tests/test_memory_pressure.py @@ -160,15 +160,17 @@ class SessionPressureTest(unittest.TestCase): def run_policy(self, body): functions = '\n'.join(function_source(name) for name in ( 'bl_memory_read', 'bl_memory_tight', 'bl_memory_critical', + 'bl_client_can_pageout', 'bl_client_pressure', 'bl_client_pressure_result', 'bl_session_pressure', 'bl_zram_has_room', 'bl_watch_nap', 'bl_zram_pick', 'bl_tier_note', 'bl_tier_readback')) functions = functions.replace('/proc/meminfo', str(self.root / 'meminfo')) functions = functions.replace('/proc/pressure/memory', str(self.root / 'pressure')) harness = ''' set -u _bl_game=1 _bl_tier_at=-1 _bl_tier_backoff=30 _bl_tier_pushed=0 _bl_tier_back=0 _bl_tier_targets=() _bl_tier_swaps=() _bl_tier_starts=() _bl_pids=(999) -_bl_pressure_at=-1 _bl_packed=-1 +_bl_pressure_at=-1 _bl_pressure_backoff=30 _bl_packed=-1 rss=$((1536 * 1024)) swap=0 pushed=$((1024 * 1024)) alive="999 321 654" started=100 complete=1 step() { :; } +bl_game_focused() { [ "${focused:-1}" = 1 ]; } bl_proc_start() { _bl_start=; case " $alive " in *" $1 "*) _bl_start=$started; return 0 ;; esac; return 1; } nap() { echo "nap:$1"; } bl_session_others() { _bl_session=(321 654); } @@ -205,6 +207,53 @@ SECONDS=30; bl_session_pressure def test_no_game_does_not_compress_the_session(self): self.assertEqual([], self.run_policy('_bl_game=0; bl_session_pressure')) + def test_disabled_idle_compression_does_not_compress_the_session(self): + self.assertEqual(['send:1:client'], self.run_policy('BL_ZRAM_IDLE=0; bl_client_pressure; bl_session_pressure')) + + def test_disabled_idle_compression_signals_only_launcher_processes(self): + sender = (function_source('bl_zram_send') + '\n' + function_source('bl_zram_finish')).replace('/tmp/.bl-zram', str(self.root / 'control')) + self.assertEqual(['kill:-URG 999 998', 'mode:1'], self.run_policy(''' +_bl_pids=(999 998) +kill() { echo "kill:$*"; } +bl_zram_wait() { _bl_pageout_complete=1; } +bl_zram_scan() { :; } +''' + sender + ''' +BL_ZRAM_IDLE=0; bl_client_pressure; bl_session_pressure +echo "mode:$(cat ''' + str(self.root / 'control') + ''')" +''')) + + def test_disabled_idle_compression_reclaims_only_the_launcher_before_focus(self): + self.memory(available=1700) + self.assertEqual(['send:1:client'], self.run_policy(''' +BL_ZRAM_IDLE=0 focused=0 +bl_client_pressure +bl_session_pressure +''')) + + def test_disabled_idle_compression_respects_launcher_setting_and_threshold(self): + self.memory(available=1700) + self.assertEqual([], self.run_policy('BL_ZRAM_IDLE=0 BL_ZRAM_CLIENT=0; bl_client_pressure; bl_session_pressure')) + self.memory(available=1900) + self.assertEqual([], self.run_policy('BL_ZRAM_IDLE=0; bl_client_pressure; bl_session_pressure')) + + def test_game_reclaim_requires_focus(self): + self.assertEqual([], self.run_policy('focused=0; bl_session_pressure')) + + def test_game_reclaim_runs_when_focus_is_unknown(self): + launch = self.root / 'launch' + (launch / 'agent').mkdir(parents=True) + body = function_source('bl_game_focused') + f'\nBL_LAUNCH_DIR={launch} _bl_apps=7\n' + self.assertEqual(['send:1:session'], self.run_policy(body + 'bl_session_pressure')) + (launch / 'agent' / 'focus.json').write_text('{"focusedApp": 9}') + self.assertEqual([], self.run_policy(body + 'bl_session_pressure')) + self.assertEqual(['unfocused'], self.run_policy(body + 'bl_game_focused || echo unfocused')) + (launch / 'agent' / 'focus.json').unlink() + self.assertEqual(['unfocused'], self.run_policy(body + 'bl_game_focused || echo unfocused')) + + def test_launcher_pressure_remains_available_on_larger_devices(self): + self.memory(total=15360, available=1400) + self.assertEqual(['send:1:client'], self.run_policy('BL_ZRAM_IDLE=0; bl_client_pressure; bl_session_pressure')) + def test_enough_available_memory_does_not_compress_even_with_stalls(self): self.memory(available=3072, psi='5.00') self.assertEqual([], self.run_policy('bl_session_pressure')) @@ -433,6 +482,7 @@ bl_zram_wait() {{ [ "$1" != 123 ] || client_rss=$((client_rss - {reclaimed * 1024})) }} bl_tier_note() {{ :; }} +bl_game_focused() {{ :; }} ''' + source + f''' bl_memory_read _bl_fall={fall * 1024} diff --git a/tools/tests/test_output_refresh.py b/tools/tests/test_output_refresh.py index 456e230d4e..5ad9aa36ed 100644 --- a/tools/tests/test_output_refresh.py +++ b/tools/tests/test_output_refresh.py @@ -70,6 +70,7 @@ static void send_toplevel_configure(struct surface *s) { (void)s; resizes++; } #define stream_forget_all(...) ((void)0) #define pointer_delta(...) ((void)0) #define deliver_touch(m) ((void)0) +#define deliver_pen(m) ((void)0) #define deliver_pointer(m) (pointers++) static void on_vsync(int64_t ns) { assert(ns > 0); ticks++; } static void vk_present_set_scale_mode(int mode, int alignment) { diff --git a/tools/tests/test_pen_emulation.py b/tools/tests/test_pen_emulation.py new file mode 100644 index 0000000000..1cf2b4b485 --- /dev/null +++ b/tools/tests/test_pen_emulation.py @@ -0,0 +1,102 @@ +import os +from pathlib import Path +import re +import shutil +import subprocess +import tempfile +import unittest + +REPO = Path(__file__).resolve().parents[2] +SOURCE = REPO / 'app/src/main/cpp/waylandcomp/src/compositor.c' +PEN_STREAM = REPO / 'app/src/main/java/com/droiddeck/launcher/input/PenStream.kt' + + +def function(source, signature): + start = source.index(signature) + return source[start:source.index('\n}\n', start) + 3] + + +class PenEmulationTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + compiler = shutil.which(os.environ.get('CC', 'cc')) + if compiler is None: + raise unittest.SkipTest('A host C compiler is required') + source = SOURCE.read_text() + cls.temp = tempfile.TemporaryDirectory(prefix='droiddeck-pen-emulation-') + cls.addClassCleanup(cls.temp.cleanup) + folder = Path(cls.temp.name) + start = source.index('struct input_msg {') + (folder / 'input_msg.inc').write_text(source[start:source.index('\n', start) + 1]) + start = source.index('#define PEN_IN ') + end = source.index('static struct pen_state g_pen;\n', start) + (folder / 'pen_state.inc').write_text(source[start:source.index('\n', end) + 1]) + (folder / 'pen.inc').write_text(''.join(function(source, signature) for signature in ( + 'static int pointer_locked_for_cursor(void) {', + 'static void input_output_to_scene(double px, double py, double *x, double *y) {', + 'static int pen_buttons(int flags) {', + 'static void pen_release(int buttons) {', + 'static void deliver_pen(const struct input_msg *m) {'))) + start = source.index('#define for_each_pointer_of(client, sp)') + (folder / 'pointer.inc').write_text( + function(source, 'static struct seat_pointer *pointer_for(struct wl_client *client) {') + + source[start:source.index('#define for_each_keyboard_of', start)] + + ''.join(function(source, signature) for signature in ( + 'static void pointer_focus(struct wl_resource *target, wl_fixed_t fx, wl_fixed_t fy) {', + 'static void pointer_input(double x, double y, int relative, uint32_t button, int pressed) {', + 'static void pointer_event(double x, double y, uint32_t button, int pressed) {', + 'static void pointer_button(uint32_t button, int pressed) {'))) + cls.binary = folder / 'pen-test' + cls.pointer_binary = folder / 'pen-pointer-test' + for harness, binary in (('pen_emulation_harness.c', cls.binary), + ('pen_pointer_harness.c', cls.pointer_binary)): + subprocess.run([compiler, '-std=c11', '-Wall', '-Wextra', '-Werror', '-I', str(folder), + str(REPO / 'tools/tests' / harness), + '-o', str(binary)], check=True, capture_output=True, text=True) + + def check_case(self, case, binary=None): + result = subprocess.run([str(binary or self.binary), case], capture_output=True, text=True) + self.assertEqual(result.returncode, 0, result.stdout + result.stderr) + + def test_flags_match_the_kotlin_pen_stream(self): + native = dict(re.findall(r'^#define (PEN_[A-Z]+) \(1 << (\d+)\)$', SOURCE.read_text(), re.MULTILINE)) + kotlin = dict(re.findall(r'^\s*const val (PEN_[A-Z]+) = 1 shl (\d+)$', PEN_STREAM.read_text(), re.MULTILINE)) + self.assertEqual({'PEN_IN', 'PEN_TIP', 'PEN_RIGHT', 'PEN_MIDDLE'}, set(native)) + self.assertEqual(native, kotlin) + + def test_hover_moves_the_pointer_in_scene_coordinates(self): + self.check_case('hover') + + def test_tip_presses_and_releases_the_left_button_once(self): + self.check_case('tip') + + def test_buttons_press_after_motion_and_before_releases(self): + self.check_case('buttons') + + def test_leaving_proximity_releases_every_button_without_motion(self): + self.check_case('out') + + def test_pointer_lock_blocks_motion_but_passes_buttons(self): + self.check_case('lock') + + def test_lost_records_still_release_held_buttons(self): + self.check_case('lost') + + def test_relative_origin_resets_when_proximity_starts_and_ends(self): + self.check_case('raw') + + def test_side_button_release_keeps_the_grab(self): + self.check_case('side', self.pointer_binary) + + def test_swapping_buttons_in_one_record_keeps_the_grab(self): + self.check_case('swap', self.pointer_binary) + + def test_a_button_release_from_another_pointer_keeps_the_grab(self): + self.check_case('mouse', self.pointer_binary) + + def test_a_window_closed_by_a_button_release_is_not_grabbed_again(self): + self.check_case('gone', self.pointer_binary) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/tests/test_pen_localization.py b/tools/tests/test_pen_localization.py new file mode 100644 index 0000000000..55596d1915 --- /dev/null +++ b/tools/tests/test_pen_localization.py @@ -0,0 +1,39 @@ +from pathlib import Path +import re +import unittest +import xml.etree.ElementTree as ET + + +ROOT = Path(__file__).resolve().parents[2] +RES = ROOT / "app/src/main/res" + + +def strings(path): + return { + element.attrib["name"]: "".join(element.itertext()) + for element in ET.parse(path).getroot() + if element.tag == "string" and element.get("translatable") != "false" + } + + +class PenLocalizationTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.required = [key for key in strings(RES / "values/strings.xml") if key.startswith("mode_pen")] + language_source = (ROOT / "app/src/main/java/com/droiddeck/launcher/core/AppLanguage.kt").read_text(encoding="utf-8") + tags = re.findall(r'"([a-zA-Z0-9-]+)"', re.search(r"val supported:.*?listOf\((.*?)\)", language_source, re.S).group(1)) + special = {"id": "in", "es-419": "b+es+419", "pt-BR": "pt"} + cls.locales = { + tag: strings(RES / f"values-{special.get(tag, tag.replace('-', '-r'))}/strings.xml") + for tag in tags if tag != "en" + } + + def test_every_supported_language_translates_the_pen_settings(self): + for locale, translated in self.locales.items(): + for key in self.required: + with self.subTest(locale=locale, key=key): + self.assertTrue(translated.get(key, "").strip(), "Missing translation would fall back to English") + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_retire_test_builds.py b/tools/tests/test_retire_test_builds.py new file mode 100644 index 0000000000..8f89f08860 --- /dev/null +++ b/tools/tests/test_retire_test_builds.py @@ -0,0 +1,52 @@ +import unittest + +from tools.release.update_catalog import ApiError, in_preview, iso_millis, keeps_test_build +from tools.release.retire_test_builds import retired + +MERGED = "2026-11-14T20:00:00Z" +NOW = iso_millis(MERGED) + 3600_000 + + +class FakeSource: + def __init__(self, status=None): + self.status = status + self.asked = [] + + def get(self, path): + self.asked.append(path) + if self.status is None: + raise ApiError(404, "no") + return {"status": self.status} + + +def pull(state="closed", merged_at=MERGED, draft=False, base="main"): + return {"state": state, "merged_at": merged_at, "merge_commit_sha": "a" * 40, "draft": draft, "base": {"ref": base}} + + +class RetireTestBuildsTest(unittest.TestCase): + def test_an_open_pr_keeps_its_build(self): + self.assertFalse(retired(pull(state="open", merged_at=None), FakeSource("ahead"), "o/r", "b" * 40)) + + def test_a_closed_unmerged_pr_loses_it_at_once(self): + self.assertTrue(retired(pull(merged_at=None), FakeSource(), "o/r", None)) + + def test_a_merged_pr_keeps_it_until_a_preview_carries_the_merge(self): + self.assertFalse(in_preview(FakeSource("behind"), "o/r", pull(), "b" * 40, NOW)) + self.assertFalse(in_preview(FakeSource(), "o/r", pull(), "b" * 40, NOW)) + self.assertFalse(in_preview(FakeSource("ahead"), "o/r", pull(), None, NOW)) + self.assertTrue(in_preview(FakeSource("ahead"), "o/r", pull(), "b" * 40, NOW)) + self.assertTrue(in_preview(FakeSource("identical"), "o/r", pull(), "a" * 40, NOW)) + + def test_a_merge_no_preview_ever_carries_is_let_go_after_the_grace(self): + self.assertTrue(in_preview(FakeSource(), "o/r", pull(), None, NOW + 4 * 86_400_000)) + + def test_the_catalog_lists_open_and_merged_main_prs(self): + self.assertTrue(keeps_test_build(pull(state="open", merged_at=None))) + self.assertTrue(keeps_test_build(pull())) + self.assertFalse(keeps_test_build(pull(merged_at=None))) + self.assertFalse(keeps_test_build(pull(draft=True))) + self.assertFalse(keeps_test_build(pull(base="release"))) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_update_catalog.py b/tools/tests/test_update_catalog.py index 5ec076d1c6..28d67b601f 100644 --- a/tools/tests/test_update_catalog.py +++ b/tools/tests/test_update_catalog.py @@ -1,8 +1,12 @@ +import base64 import unittest from tools.release.update_catalog import ( Cache, asset_for_suffix, + build_catalog, + complete_apks, + newest_complete, merged_pr, ci_description, parse_gradle, @@ -59,6 +63,64 @@ pubg com.tencent.ig -pubg self.assertEqual("DroidDeck-main-deadbee.apk", standard["name"]) self.assertEqual("DroidDeck-main-deadbee-pubg.apk", pubg["name"]) + def test_the_apk_named_for_the_build_commit_wins_over_a_previous_push(self): + def apk(name, digit): + return {"name": name, "size": 1, "digest": "sha256:" + digit * 64, "browser_download_url": "https://example/" + name} + assets = [apk("DroidDeck-PR.7-1111111.apk", "a"), apk("DroidDeck-PR.7-2222222.apk", "b"), + apk("DroidDeck-PR.7-1111111-pubg.apk", "c"), apk("DroidDeck-PR.7-2222222-pubg.apk", "d")] + suffixes = ["", "-pubg"] + self.assertEqual("DroidDeck-PR.7-2222222.apk", asset_for_suffix(assets, "", suffixes, "2222222abc")["name"]) + self.assertEqual("DroidDeck-PR.7-2222222-pubg.apk", asset_for_suffix(assets, "-pubg", suffixes, "2222222abc")["name"]) + self.assertEqual("DroidDeck-PR.7-1111111.apk", asset_for_suffix(assets, "", suffixes)["name"]) + + def test_a_preview_counts_only_with_every_package_and_digest(self): + variants = [("com.droiddeck.launcher", ""), ("com.tencent.ig", "-pubg")] + good = {"sha256": "a" * 64, "signerSha256": "b" * 64} + self.assertTrue(complete_apks({"apks": {"com.droiddeck.launcher": good, "com.tencent.ig": good}}, variants)) + self.assertFalse(complete_apks({"apks": {"com.droiddeck.launcher": good}}, variants)) + self.assertFalse(complete_apks({"apks": {}}, variants)) + self.assertFalse(complete_apks({"apks": {"com.droiddeck.launcher": good, "com.tencent.ig": {"sha256": "x"}}}, variants)) + + def test_no_preview_is_offered_until_one_has_every_apk(self): + variants = [("com.droiddeck.launcher", "")] + good = {"com.droiddeck.launcher": {"sha256": "a" * 64, "signerSha256": "b" * 64}} + uploading = {"commit": "2" * 40, "apks": {}} + done = {"commit": "1" * 40, "apks": good} + self.assertIsNone(newest_complete([uploading], variants)) + self.assertIsNone(newest_complete([], variants)) + self.assertIs(done, newest_complete([uploading, done], variants)) + + def test_the_catalog_publishes_no_preview_while_its_apks_are_uploading(self): + commit = "c" * 40 + files = { + "app/build.gradle": " versionCode 19\n versionName \"0.7.1\"\n", + "tools/release/variants.txt": "standard com.droiddeck.launcher -\n", + "keystore/release-signer.sha256": "b" * 64 + "\n", + } + + class FakeGitHub: + def get_all(self, path, limit=1000): + if "DroidDeck-CI/releases" in path: + return [{ + "tag_name": f"main-{commit[:7]}", "prerelease": True, "assets": [], + "published_at": "2026-11-14T10:00:00Z", + "body": f"**Merged to main** - [PR #5](u): fix: x\n\nCommit: {commit}\nVersionCode: 19\n", + }] + return [] + + def get(self, path): + for name, text in files.items(): + if f"/contents/{name.replace('/', '%2F')}?" in path: + return {"encoding": "base64", "content": base64.b64encode(text.encode()).decode()} + if "/commits/" in path: + return {"author": {"login": "dev"}, "commit": {"committer": {"date": "2026-11-14T09:59:00Z"}}} + raise AssertionError(path) + + gh = FakeGitHub() + catalog = build_catalog(gh, gh, "Droid-Deck/DroidDeck", "Droid-Deck/DroidDeck-CI") + self.assertIsNone(catalog["preview"]) + self.assertEqual([commit], [p["commit"] for p in catalog["previews"]]) + def test_ci_description(self): title, summary = ci_description( { diff --git a/tools/tests/test_wincomponents.py b/tools/tests/test_wincomponents.py index 7423fb2bbf..54e5fed490 100644 --- a/tools/tests/test_wincomponents.py +++ b/tools/tests/test_wincomponents.py @@ -41,8 +41,37 @@ class WinComponentsTest(unittest.TestCase): def proton(self, arm=True): root = Path(self.tmp.name) / ("arm-proton" if arm else "x64-proton") (root / "files/lib/wine" / ("aarch64-unix" if arm else "x86_64-unix")).mkdir(parents=True) + builtins = root / "files/lib/wine/aarch64-windows" + builtins.mkdir(parents=True) + (builtins / "wineboot.exe").write_bytes(self.program_image(0xAA64, ["ucrtbase.dll"])) + (builtins / "steam.exe").write_bytes(self.program_image(0x8664, ["vulkan-1.dll"])) + (builtins / "d3dx9_43.dll").write_bytes(self.program_image(0xAA64, ["d3dcompiler_43.dll"])) return root / "proton" + def program_image(self, machine, imports): + image = bytearray(0x400) + image[:2] = b"MZ" + image[60:64] = (64).to_bytes(4, "little") + image[64:68] = b"PE\0\0" + image[68:70] = machine.to_bytes(2, "little") + image[70:72] = (1).to_bytes(2, "little") + image[84:86] = (240).to_bytes(2, "little") + image[88:90] = (0x20B).to_bytes(2, "little") + image[196:200] = (16).to_bytes(4, "little") + image[208:212] = (0x1000).to_bytes(4, "little") + image[212:216] = (20 * (len(imports) + 1)).to_bytes(4, "little") + section = 88 + 240 + image[section + 8:section + 12] = (0x200).to_bytes(4, "little") + image[section + 12:section + 16] = (0x1000).to_bytes(4, "little") + image[section + 16:section + 20] = (0x200).to_bytes(4, "little") + image[section + 20:section + 24] = (0x200).to_bytes(4, "little") + name = 20 * (len(imports) + 1) + for index, dll in enumerate(imports): + image[0x200 + index * 20 + 12:0x200 + index * 20 + 16] = (0x1000 + name).to_bytes(4, "little") + image[0x200 + name:0x200 + name + len(dll)] = dll.encode() + name += len(dll) + 1 + return bytes(image) + def pe_image(self, machine): head = bytearray(64) head[:2] = b"MZ" @@ -92,17 +121,65 @@ class WinComponentsTest(unittest.TestCase): self.assertEqual(names, ["ucrtbase"]) self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/ucrtbase.dll"), 0x8664) - def test_x64_visual_cpp_runtime_is_placed_in_arm64_system32(self): + def test_x64_dlls_proton_programs_do_not_import_are_placed_in_arm64_system32(self): proton = self.proton() - self.component("vc", ["msvcp140", "vcruntime140_1"], { - "system32/msvcp140.dll": self.pe_image(0x8664), - "system32/vcruntime140_1.dll": self.pe_image(0x8664), - }) + names = ["concrt140", "d3dcompiler_43", "msvcp140", "vcruntime140_1", "vulkan-1"] + self.component("vc", names, {"system32/%s.dll" % name: self.pe_image(0x8664) for name in names}) self.pick("vc") - names, _ = self.apply(proton) - self.assertEqual(names, ["msvcp140", "vcruntime140_1"]) + placed, _ = self.apply(proton) + self.assertEqual(placed, names) + for name in names: + self.assertEqual(MODULE["pe_machine"](self.pfx / ("system32/%s.dll" % name)), 0x8664) + + def test_x64_d3dx9_and_its_compiler_stay_placed_on_every_launch(self): + proton = self.proton() + self.component("d3dx9", ["d3dx9_43"], {"system32/d3dx9_43.dll": self.pe_image(0x8664)}) + self.component("d3dcompiler", ["d3dcompiler_43"], {"system32/d3dcompiler_43.dll": self.pe_image(0x8664)}) + self.pick("d3dx9", "d3dcompiler") + for _ in range(2): + placed, _ = self.apply(proton) + self.assertEqual(placed, ["d3dx9_43", "d3dcompiler_43"]) + self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/d3dx9_43.dll"), 0x8664) + self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/d3dcompiler_43.dll"), 0x8664) + + def test_x64_compiler_alone_is_placed_although_a_builtin_dll_imports_it(self): + proton = self.proton() + self.component("d3dcompiler", ["d3dcompiler_43"], {"system32/d3dcompiler_43.dll": self.pe_image(0x8664)}) + self.pick("d3dcompiler") + placed, _ = self.apply(proton) + self.assertEqual(placed, ["d3dcompiler_43"]) + self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/d3dcompiler_43.dll"), 0x8664) + + def test_x64_proton_program_imports_do_not_make_a_dll_foreign(self): + proton = self.proton() + self.component("vk", ["vulkan-1"], {"system32/vulkan-1.dll": self.pe_image(0x8664)}) + self.pick("vk") + placed, _ = self.apply(proton) + self.assertEqual(placed, ["vulkan-1"]) + self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/vulkan-1.dll"), 0x8664) + + def test_partly_installed_x64_visual_cpp_runtime_stays_x64(self): + proton = self.proton() + self.pfx.joinpath("system32").mkdir(parents=True) + self.pfx.joinpath("system32/vcruntime140.dll").write_bytes(self.pe_image(0x8664)) + self.component("vc", ["msvcp140"], {"system32/msvcp140.dll": self.pe_image(0x8664)}) + self.pick("vc") + placed, _ = self.apply(proton) + self.assertEqual(placed, ["msvcp140"]) self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/msvcp140.dll"), 0x8664) - self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/vcruntime140_1.dll"), 0x8664) + self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/vcruntime140.dll"), 0x8664) + + def test_deselected_component_restores_the_saved_x64_dll(self): + proton = self.proton() + self.pfx.joinpath("system32").mkdir(parents=True) + self.pfx.joinpath("system32/d3dx9_43.dll").write_bytes(self.pe_image(0x8664)) + self.component("d3dx9", ["d3dx9_43"], {"system32/d3dx9_43.dll": self.program_image(0xAA64, [])}) + self.pick("d3dx9") + self.apply(proton) + self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/d3dx9_43.dll"), 0xAA64) + self.pick() + self.apply(proton) + self.assertEqual(MODULE["pe_machine"](self.pfx / "system32/d3dx9_43.dll"), 0x8664) def test_compatible_copy_keeps_override_when_other_architecture_copy_is_skipped(self): proton = self.proton() diff --git a/tools/tests/test_xbox_launch.py b/tools/tests/test_xbox_launch.py index 1701d6ea4b..76137248e6 100644 --- a/tools/tests/test_xbox_launch.py +++ b/tools/tests/test_xbox_launch.py @@ -211,3 +211,184 @@ class XboxLaunchTest(unittest.TestCase): with patch('subprocess.run', **outcome), patch('sys.stderr', new_callable=io.StringIO) as err: self.assertIsNone(xbox['register_classes']('/selected/proton', prefix, {})) self.assertIn('registration failed', err.getvalue()) + + +def pe_with_exports(names, forward=None, machine=0x8664, unnamed=0): + """A minimal x64 PE image whose export table names `names`; with `forward`, every export is forwarded there. + `unnamed` adds that many ordinal-only exports after the named ones.""" + rva, raw = 0x1000, 0x200 + functions = rva + 40 + name_pointers = functions + 4 * (len(names) + unnamed) + ordinals = name_pointers + 4 * len(names) + strings = ordinals + 2 * len(names) + blob = bytearray() + name_rvas, forward_rvas = [], [] + for name in names: + name_rvas.append(strings + len(blob)) + blob += name.encode() + b'\0' + for name in names: + forward_rvas.append(strings + len(blob)) + if forward: + blob += ('%s.%s' % (forward, name)).encode() + b'\0' + size = strings + len(blob) - rva + directory = bytearray(40) + directory[16:20] = (1).to_bytes(4, 'little') + directory[20:24] = (len(names) + unnamed).to_bytes(4, 'little') + directory[24:28] = len(names).to_bytes(4, 'little') + directory[28:32] = functions.to_bytes(4, 'little') + directory[32:36] = name_pointers.to_bytes(4, 'little') + directory[36:40] = ordinals.to_bytes(4, 'little') + section = bytearray(directory) + for index in range(len(names)): + section += (forward_rvas[index] if forward else 0x3000 + index).to_bytes(4, 'little') + for index in range(unnamed): + section += (0x4000 + index).to_bytes(4, 'little') + for value in name_rvas: + section += value.to_bytes(4, 'little') + for index in range(len(names)): + section += index.to_bytes(2, 'little') + section += blob + image = bytearray(raw) + image[:2] = b'MZ' + image[60:64] = (0x40).to_bytes(4, 'little') + image[0x40:0x44] = b'PE\0\0' + image[0x44:0x46] = machine.to_bytes(2, 'little') + image[0x46:0x48] = (1).to_bytes(2, 'little') + image[0x54:0x56] = (240).to_bytes(2, 'little') + optional = 0x58 + image[optional:optional + 2] = (0x20B).to_bytes(2, 'little') + image[optional + 108:optional + 112] = (16).to_bytes(4, 'little') + image[optional + 112:optional + 116] = rva.to_bytes(4, 'little') + image[optional + 116:optional + 120] = size.to_bytes(4, 'little') + header = optional + 240 + image[header + 8:header + 12] = len(section).to_bytes(4, 'little') + image[header + 12:header + 16] = rva.to_bytes(4, 'little') + image[header + 16:header + 20] = len(section).to_bytes(4, 'little') + image[header + 20:header + 24] = raw.to_bytes(4, 'little') + return bytes(image + section) + + +class PlayFabProxyTest(unittest.TestCase): + SDK = pe_with_exports(xbox['PGS_EXPORTS']) + NEWER_SDK = SDK + b'\0update' + PROXY = pe_with_exports(xbox['PGS_EXPORTS'], forward='nexus_pgs_native') + + def stage(self, root, proxy=PROXY): + runtime = Path(root) / 'runtime' + if proxy is not None: + (runtime / 'compat').mkdir(parents=True, exist_ok=True) + (runtime / 'compat/PlayFabGameSave.dll').write_bytes(proxy) + with patch.dict(xbox['stage_playfab_proxy'].__globals__, PGS_PROXY=runtime / 'compat/PlayFabGameSave.dll'), \ + patch('sys.stderr', new_callable=io.StringIO): + return xbox['stage_playfab_proxy'](Path(root) / 'game') + + def game(self, root, data, sub='Bin'): + folder = Path(root) / 'game' / sub + folder.mkdir(parents=True) + (folder / 'PlayFabGameSave.dll').write_bytes(data) + return folder + + def test_sdk_and_proxy_are_told_apart_by_their_exports(self): + self.assertTrue(xbox['playfab_sdk'](self.SDK)) + self.assertFalse(xbox['playfab_proxy'](self.SDK)) + self.assertTrue(xbox['playfab_proxy'](self.PROXY)) + self.assertFalse(xbox['playfab_sdk'](self.PROXY)) + other = pe_with_exports(list(xbox['PGS_EXPORTS'][:-1]) + ['PFGameSaveFilesSomethingNew']) + self.assertFalse(xbox['playfab_sdk'](other)) + self.assertFalse(xbox['playfab_sdk'](pe_with_exports(xbox['PGS_EXPORTS'], machine=0xAA64))) + self.assertIsNone(xbox['pe_exports'](b'not a pe image')) + self.assertEqual(xbox['pe_exports'](pe_with_exports(['A', 'B'], unnamed=1))[0], 3) + self.assertFalse(xbox['playfab_sdk'](pe_with_exports(xbox['PGS_EXPORTS'], unnamed=1))) + self.assertFalse(xbox['playfab_proxy'](pe_with_exports(xbox['PGS_EXPORTS'], forward='nexus_pgs_native', unnamed=1))) + + def test_first_launch_keeps_the_sdk_and_puts_the_proxy_in_front(self): + with tempfile.TemporaryDirectory() as root: + folder = self.game(root, self.SDK) + self.assertEqual(self.stage(root), 1) + self.assertEqual((folder / 'nexus_pgs_native.dll').read_bytes(), self.SDK) + self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), self.PROXY) + self.assertEqual(self.stage(root), 1) + self.assertEqual((folder / 'nexus_pgs_native.dll').read_bytes(), self.SDK) + self.assertEqual(sorted(path.name for path in folder.iterdir()), ['PlayFabGameSave.dll', 'nexus_pgs_native.dll']) + + def test_a_game_update_replaces_the_kept_sdk(self): + with tempfile.TemporaryDirectory() as root: + folder = self.game(root, self.SDK) + self.stage(root) + (folder / 'PlayFabGameSave.dll').write_bytes(self.NEWER_SDK) + self.assertEqual(self.stage(root), 1) + self.assertEqual((folder / 'nexus_pgs_native.dll').read_bytes(), self.NEWER_SDK) + self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), self.PROXY) + + def test_an_older_proxy_is_refreshed_only_while_its_sdk_is_there(self): + older = self.PROXY + b'\0older' + with tempfile.TemporaryDirectory() as root: + folder = self.game(root, older) + (folder / 'nexus_pgs_native.dll').write_bytes(self.SDK) + self.assertEqual(self.stage(root), 1) + self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), self.PROXY) + with tempfile.TemporaryDirectory() as root: + folder = self.game(root, older) + self.assertEqual(self.stage(root), 0) + self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), older) + + def test_an_unknown_file_or_link_in_place_of_the_kept_sdk_is_never_overwritten(self): + with tempfile.TemporaryDirectory() as root: + folder = self.game(root, self.SDK) + (folder / 'nexus_pgs_native.dll').write_bytes(b'MZ someone else') + self.assertEqual(self.stage(root), 0) + self.assertEqual((folder / 'nexus_pgs_native.dll').read_bytes(), b'MZ someone else') + self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), self.SDK) + with tempfile.TemporaryDirectory() as root: + folder = self.game(root, self.SDK) + target = Path(root) / 'elsewhere.dll' + target.write_bytes(self.SDK) + (folder / 'nexus_pgs_native.dll').symlink_to(target) + self.assertEqual(self.stage(root), 0) + self.assertTrue((folder / 'nexus_pgs_native.dll').is_symlink()) + self.assertEqual(target.read_bytes(), self.SDK) + self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), self.SDK) + + def test_unknown_sdk_symlinks_and_a_runtime_without_the_proxy_are_left_alone(self): + with tempfile.TemporaryDirectory() as root: + unknown = pe_with_exports(['PFGameSaveFilesInitialize']) + folder = self.game(root, unknown) + self.assertEqual(self.stage(root), 0) + self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), unknown) + self.assertFalse((folder / 'nexus_pgs_native.dll').exists()) + with tempfile.TemporaryDirectory() as root: + folder = self.game(root, self.SDK) + self.assertEqual(self.stage(root, proxy=None), 0) + self.assertEqual((folder / 'PlayFabGameSave.dll').read_bytes(), self.SDK) + with tempfile.TemporaryDirectory() as root: + target = Path(root) / 'elsewhere.dll' + target.write_bytes(self.SDK) + folder = Path(root) / 'game' + folder.mkdir() + (folder / 'PlayFabGameSave.dll').symlink_to(target) + self.assertEqual(self.stage(root), 0) + self.assertEqual(target.read_bytes(), self.SDK) + + def test_launch_stages_the_proxy_without_dll_overrides_and_survives_a_failure(self): + with tempfile.TemporaryDirectory() as root: + root = Path(root) + runtime = root / 'windows' + runtime.mkdir() + for name in xbox['DLLS']: + (runtime / name).touch() + store = {'find_store_game': lambda argv: (root, {'store': 'xbox', 'id': 'GAME'}), + 'ask': unittest.mock.Mock(return_value={'ok': True, 'socket': '/service', 'lease': 'lease-1', + 'exe': '/Game.exe'})} + wine = unittest.mock.Mock(return_value=0) + staged = [] + def failing(folder): + raise RuntimeError('unreadable game folder') + for stage in (lambda folder: staged.append(folder) or 1, failing): + wine.reset_mock() + with patch('runpy.run_path', return_value=store), patch('sys.stderr', new_callable=io.StringIO), \ + patch.dict(xbox['launch'].__globals__, RUNTIME=root, bridge=lambda path: (1, 'key', lambda: None), + wine=wine, stage_playfab_proxy=stage): + self.assertEqual(xbox['launch'](['/proton', 'waitforexitandrun', '/Game.exe'], + {'BL_LAUNCH_DIR': '/launch', 'WINEDLLOVERRIDES': 'd3d11=n'}), 0) + self.assertEqual(wine.call_args.args[1]['WINEDLLOVERRIDES'], 'd3d11=n') + self.assertEqual(staged, [root]) diff --git a/tools/tests/vk_terminal_callers_test.c b/tools/tests/vk_terminal_callers_test.c index b2764c0da7..c5857a7710 100644 --- a/tools/tests/vk_terminal_callers_test.c +++ b/tools/tests/vk_terminal_callers_test.c @@ -65,6 +65,7 @@ int vkp_cardboard_active(void) { return 0; } void vkp_cardboard_begin_frame(void) {} VkImage vkp_cardboard_run(VkCommandBuffer c, VkImage s, int sw, int sh, int ow, int oh) { return s; } int vk_loader_open(const char *a, const char *b, const char *c) { assert(0); return -1; } +void vk_loader_close(void) { assert(0); } void vk_loader_load_instance(VkInstance i) { assert(0); } void vk_loader_load_device(VkDevice d) { assert(0); } PFN_vkGetInstanceProcAddr vk_loader_gipa(void) { return NULL; } diff --git a/tools/ubuntu/patches/mesa/0004-zink-recreate-every-sampler-view-surface-on-rebind.patch b/tools/ubuntu/patches/mesa/0004-zink-recreate-every-sampler-view-surface-on-rebind.patch index c4f5b3df1d..3c386827c0 100644 --- a/tools/ubuntu/patches/mesa/0004-zink-recreate-every-sampler-view-surface-on-rebind.patch +++ b/tools/ubuntu/patches/mesa/0004-zink-recreate-every-sampler-view-surface-on-rebind.patch @@ -17,6 +17,11 @@ helper (Chromium on ANGLE on Zink) hit this within seconds of fast Home shelf scrolling on a Pixel 10 Pro Fold and segfaulted in the driver's vkUpdateDescriptorSetWithTemplate. Rebuild all of the view's surfaces with init_sampler_view() instead. Still present in Mesa main. + +zink_rebind_all_images() rebuilds a view once, through the rebind_count +guard, so a second slot bound to the same view used to skip its descriptor +refresh and keep the old VkImageView. Refresh every slot whose cached view +no longer matches. --- diff --git a/src/gallium/drivers/zink/zink_context.c b/src/gallium/drivers/zink/zink_context.c --- a/src/gallium/drivers/zink/zink_context.c @@ -32,13 +37,22 @@ diff --git a/src/gallium/drivers/zink/zink_context.c b/src/gallium/drivers/zink/ ctx->invalidate_descriptor_state(ctx, i, ZINK_DESCRIPTOR_TYPE_SAMPLER_VIEW, j, 1); update_descriptor_state_sampler(ctx, i, j, res); } -@@ -5457,8 +5457,7 @@ zink_rebind_all_images(struct zink_context *ctx) +@@ -5455,10 +5455,15 @@ zink_rebind_all_images(struct zink_context *ctx) + if (!sv || !sv->image_view || sv->base.texture->target == PIPE_BUFFER) + continue; struct zink_resource *res = zink_resource(sv->base.texture); - if (res->rebind_count != sv->rebind_count) { +- if (res->rebind_count != sv->rebind_count) { ++ bool rebuilt = res->rebind_count != sv->rebind_count; ++ if (rebuilt) { sv->rebind_count = res->rebind_count; - struct pipe_surface tmpl = pipe_surface_templ_from_sampler_view(&sv->base, &res->base.b, sv->base.target); - sv->image_view = zink_get_surface(ctx, &tmpl, &sv->ivci); + init_sampler_view(ctx, sv); ++ } ++ /* a view bound in several slots is rebuilt once; every slot still needs the new VkImageView */ ++ enum pipe_format format; ++ struct zink_surface *surface = get_imageview_for_binding(ctx, i, ZINK_DESCRIPTOR_TYPE_SAMPLER_VIEW, j, &format); ++ if (rebuilt || ctx->di.textures[i][j].imageView != surface->image_view) { ctx->invalidate_descriptor_state(ctx, i, ZINK_DESCRIPTOR_TYPE_SAMPLER_VIEW, j, 1); update_descriptor_state_sampler(ctx, i, j, res); } diff --git a/tools/venus/layer/layer.c b/tools/venus/layer/layer.c index 4df8a54ad1..2f1e7ccd7d 100644 --- a/tools/venus/layer/layer.c +++ b/tools/venus/layer/layer.c @@ -212,6 +212,8 @@ uint32_t physical_device_gaps(struct instance *inst, VkPhysicalDevice physical_d gaps |= GAP_ROBUSTNESS2; if (!features.features.multiDrawIndirect) gaps |= GAP_MULTI_DRAW; + if (!features.features.dualSrcBlend) + gaps |= GAP_DUAL_SRC_BLEND; if (!has_extension(inst, physical_device, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME)) gaps |= GAP_DEPTH_CLIP; /* No robustness2 at all: the extension is offered with robustBufferAccess2 (as robustBufferAccess) @@ -284,6 +286,8 @@ static void report_features(VkPhysicalDeviceFeatures *features, uint32_t gaps) features->textureCompressionBC = VK_TRUE; if (gaps & GAP_MULTI_DRAW) features->multiDrawIndirect = VK_TRUE; + if (gaps & GAP_DUAL_SRC_BLEND) + features->dualSrcBlend = VK_TRUE; } /* Which made-up features the application asked for, and off with them before the driver sees them. */ @@ -314,6 +318,10 @@ static uint32_t take_features(VkPhysicalDeviceFeatures *features, uint32_t gaps) requested |= GAP_MULTI_DRAW; features->multiDrawIndirect = VK_FALSE; } + if ((gaps & GAP_DUAL_SRC_BLEND) && features->dualSrcBlend) { + requested |= GAP_DUAL_SRC_BLEND; + features->dualSrcBlend = VK_FALSE; + } return requested; } @@ -323,6 +331,8 @@ static void report_limits(VkPhysicalDeviceLimits *limits, uint32_t gaps) limits->maxViewports = 16; if ((gaps & GAP_MULTI_DRAW) && limits->maxDrawIndirectCount < (1u << 30)) limits->maxDrawIndirectCount = 1u << 30; + if ((gaps & GAP_DUAL_SRC_BLEND) && !limits->maxFragmentDualSrcAttachments) + limits->maxFragmentDualSrcAttachments = 1; if (gaps & GAPS_SHADER) { limits->maxClipDistances = 8; limits->maxCullDistances = 8; @@ -616,7 +626,7 @@ static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physical_dev pthread_mutex_unlock(&global_lock); if (requested) { - layer_log("emulating%s%s%s%s%s%s%s%s%s for %s", (requested & GAP_FILL_MODE) ? " fillModeNonSolid" : "", + layer_log("emulating%s%s%s%s%s%s%s%s%s%s for %s", (requested & GAP_FILL_MODE) ? " fillModeNonSolid" : "", (requested & GAP_MULTI_VIEWPORT) ? " multiViewport" : "", (requested & GAP_CLIP_DISTANCE) ? " shaderClipDistance" : "", (requested & GAP_CULL_DISTANCE) ? " shaderCullDistance" : "", @@ -624,7 +634,8 @@ static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physical_dev (requested & GAP_BC) ? " textureCompressionBC" : "", (requested & GAP_MULTI_DRAW) ? " multiDrawIndirect" : "", (requested & GAP_DEPTH_CLIP) ? " depthClipEnable" : "", - (requested & GAP_NULL_DESCRIPTOR) ? " nullDescriptor" : "", properties.deviceName); + (requested & GAP_NULL_DESCRIPTOR) ? " nullDescriptor" : "", + (requested & GAP_DUAL_SRC_BLEND) ? " dualSrcBlend" : "", properties.deviceName); } return VK_SUCCESS; } @@ -667,8 +678,8 @@ struct hook { #define HOOK_ALIAS(name, alias, gaps) {"vk" #alias, (PFN_vkVoidFunction)name, gaps} static const struct hook device_hooks[] = { - HOOK(CreateShaderModule, GAPS_SHADER), - HOOK(DestroyShaderModule, GAPS_SHADER), + HOOK(CreateShaderModule, GAPS_SHADER | GAP_DUAL_SRC_BLEND), + HOOK(DestroyShaderModule, GAPS_SHADER | GAP_DUAL_SRC_BLEND), HOOK(CreateGraphicsPipelines, GAPS_PIPELINE), HOOK(CmdSetViewport, GAP_MULTI_VIEWPORT), HOOK(CmdSetScissor, GAP_MULTI_VIEWPORT), @@ -676,6 +687,7 @@ static const struct hook device_hooks[] = { HOOK_ALIAS(CmdSetViewportWithCount, CmdSetViewportWithCountEXT, GAP_MULTI_VIEWPORT), HOOK(CmdSetScissorWithCount, GAP_MULTI_VIEWPORT), HOOK_ALIAS(CmdSetScissorWithCount, CmdSetScissorWithCountEXT, GAP_MULTI_VIEWPORT), + HOOK(CmdSetColorBlendEquationEXT, GAP_DUAL_SRC_BLEND), HOOK(CreateImage, GAP_BC), HOOK(DestroyImage, GAP_BC), HOOK(CreateImageView, GAP_BC), diff --git a/tools/venus/layer/mali_compat.h b/tools/venus/layer/mali_compat.h index 055034ab65..a785eaff4a 100644 --- a/tools/venus/layer/mali_compat.h +++ b/tools/venus/layer/mali_compat.h @@ -29,10 +29,11 @@ enum gap { GAP_MULTI_DRAW = 1u << 6, /* multiDrawIndirect: indirect draws looped one by one */ GAP_DEPTH_CLIP = 1u << 7, /* VK_EXT_depth_clip_enable: depthClipEnable off becomes depth clamp */ GAP_NULL_DESCRIPTOR = 1u << 8, /* VK_EXT_robustness2 missing entirely: nullDescriptor stand-ins */ + GAP_DUAL_SRC_BLEND = 1u << 9, }; #define GAPS_SHADER (GAP_CLIP_DISTANCE | GAP_CULL_DISTANCE) -#define GAPS_PIPELINE (GAP_FILL_MODE | GAP_MULTI_VIEWPORT | GAPS_SHADER | GAP_DEPTH_CLIP) +#define GAPS_PIPELINE (GAP_FILL_MODE | GAP_MULTI_VIEWPORT | GAPS_SHADER | GAP_DEPTH_CLIP | GAP_DUAL_SRC_BLEND) void layer_log(const char *format, ...) __attribute__((format(printf, 1, 2))); @@ -135,7 +136,8 @@ struct instance { X(UpdateDescriptorSetWithTemplate) \ X(CmdPushDescriptorSetWithTemplate) \ X(CmdBindVertexBuffers) \ - X(CmdBindVertexBuffers2) + X(CmdBindVertexBuffers2) \ + X(CmdSetColorBlendEquationEXT) struct staging_block; @@ -183,6 +185,8 @@ struct spirv_code { bool spirv_uses_distances(const uint32_t *words, size_t count); /* The module with clip and cull distances taken out; false when it cannot be rewritten. */ bool spirv_strip_distances(const uint32_t *words, size_t count, struct spirv_code *out); +bool spirv_uses_dual_source(const uint32_t *words, size_t count); +bool spirv_strip_dual_source(const uint32_t *words, size_t count, struct spirv_code *out); enum clip_role { CLIP_STRIP, CLIP_PRODUCER, CLIP_CONSUMER }; @@ -216,6 +220,8 @@ VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer cmd, uint32_t first, ui VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount(VkCommandBuffer cmd, uint32_t count, const VkViewport *viewports); VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount(VkCommandBuffer cmd, uint32_t count, const VkRect2D *scissors); +VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT(VkCommandBuffer cmd, uint32_t first, uint32_t count, + const VkColorBlendEquationEXT *equations); /* bc.c */ VkFormat bc_substitute(VkFormat format); diff --git a/tools/venus/layer/pipeline.c b/tools/venus/layer/pipeline.c index a749c21d3e..906ef27d26 100644 --- a/tools/venus/layer/pipeline.c +++ b/tools/venus/layer/pipeline.c @@ -12,27 +12,46 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShade const VkAllocationCallbacks *allocator, VkShaderModule *module) { struct device *dev = device_from_handle(device); + VkShaderModuleCreateInfo copy = *info; size_t count = info->codeSize / sizeof(uint32_t); - if (!spirv_uses_distances(info->pCode, count)) - return dev->CreateShaderModule(device, info, allocator, module); + struct spirv_code single = {0}; + if ((dev->emulated & GAP_DUAL_SRC_BLEND) && spirv_uses_dual_source(info->pCode, count)) { + if (spirv_strip_dual_source(info->pCode, count, &single)) { + copy.pCode = single.words; + copy.codeSize = single.count * sizeof(uint32_t); + count = single.count; + } else { + layer_log("could not take the second blend source out of a shader module"); + } + } + if (!(dev->emulated & GAPS_SHADER) || !spirv_uses_distances(copy.pCode, count)) { + VkResult result = dev->CreateShaderModule(device, ©, allocator, module); + free(single.words); + return result; + } struct spirv_code stripped; - if (!spirv_strip_distances(info->pCode, count, &stripped)) { + if (!spirv_strip_distances(copy.pCode, count, &stripped)) { layer_log("could not take the clip and cull distances out of a shader module"); - return dev->CreateShaderModule(device, info, allocator, module); + VkResult result = dev->CreateShaderModule(device, ©, allocator, module); + free(single.words); + return result; } - VkShaderModuleCreateInfo copy = *info; + struct spirv_code *original = malloc(sizeof(*original)); + original->count = count; + original->words = malloc(copy.codeSize); + memcpy(original->words, copy.pCode, copy.codeSize); + free(single.words); copy.pCode = stripped.words; copy.codeSize = stripped.count * sizeof(uint32_t); VkResult result = dev->CreateShaderModule(device, ©, allocator, module); free(stripped.words); - if (result != VK_SUCCESS) + if (result != VK_SUCCESS) { + free(original->words); + free(original); return result; + } - struct spirv_code *original = malloc(sizeof(*original)); - original->count = count; - original->words = malloc(info->codeSize); - memcpy(original->words, info->pCode, info->codeSize); pthread_mutex_lock(&dev->lock); map_put(&dev->shader_modules, HANDLE(*module), original); pthread_mutex_unlock(&dev->lock); @@ -87,12 +106,15 @@ static void find_stage_code(struct device *dev, const VkPipelineShaderStageCreat struct pipeline_rewrite { VkPipelineRasterizationStateCreateInfo rasterization; + VkPipelineColorBlendStateCreateInfo blend; + VkPipelineColorBlendAttachmentState *attachments; /* VK_EXT_depth_clip_enable's state, taken out of the application's chain for the call. */ VkBaseOutStructure *clip_prev, *clip_node; VkPipelineViewportStateCreateInfo viewport; VkPipelineShaderStageCreateInfo stages[MAX_STAGES]; VkShaderModuleCreateInfo modules[MAX_STAGES]; struct spirv_code code[MAX_STAGES]; + struct spirv_code single[MAX_STAGES]; VkShaderModule temporary[MAX_STAGES]; /* Rewritten where they are, when they are not first in their stage's chain. */ VkShaderModuleCreateInfo *in_place[MAX_STAGES]; @@ -154,8 +176,17 @@ static void rewrite_shaders(struct device *dev, VkGraphicsPipelineCreateInfo *in bool any = false; for (uint32_t i = 0; i < n; i++) { find_stage_code(dev, &info->pStages[i], &code[i]); - uses[i] = code[i].words && spirv_uses_distances(code[i].words, code[i].count); - any |= uses[i]; + if ((dev->emulated & GAP_DUAL_SRC_BLEND) && code[i].inline_info && + spirv_uses_dual_source(code[i].words, code[i].count)) { + if (spirv_strip_dual_source(code[i].words, code[i].count, &rw->single[i])) { + code[i].words = rw->single[i].words; + code[i].count = rw->single[i].count; + } else { + layer_log("could not take the second blend source out of a pipeline's shader"); + } + } + uses[i] = (dev->emulated & GAPS_SHADER) && code[i].words && spirv_uses_distances(code[i].words, code[i].count); + any |= uses[i] || rw->single[i].words; } if (!any) return; @@ -196,11 +227,63 @@ static void rewrite_shaders(struct device *dev, VkGraphicsPipelineCreateInfo *in !spirv_strip_distances(code[i].words, code[i].count, &rw->code[i])) { layer_log("could not take the clip and cull distances out of a pipeline's shader"); } + if (!rw->code[i].words && rw->single[i].words) { + rw->code[i] = rw->single[i]; + rw->single[i] = (struct spirv_code){0}; + } if (rw->code[i].words) use_code(dev, info, rw, &code[i], i); } } +static bool single_source(VkBlendFactor *factor) +{ + switch (*factor) { + case VK_BLEND_FACTOR_SRC1_COLOR: + case VK_BLEND_FACTOR_SRC1_ALPHA: + *factor = VK_BLEND_FACTOR_SRC_ALPHA; + return true; + case VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR: + case VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA: + *factor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; + return true; + default: + return false; + } +} + +static bool single_source_equation(VkBlendFactor *src_color, VkBlendFactor *dst_color, VkBlendFactor *src_alpha, + VkBlendFactor *dst_alpha) +{ + bool changed = single_source(src_color); + changed |= single_source(dst_color); + changed |= single_source(src_alpha); + changed |= single_source(dst_alpha); + return changed; +} + +static void rewrite_blend(const VkGraphicsPipelineCreateInfo *info, struct pipeline_rewrite *rw) +{ + const VkPipelineColorBlendStateCreateInfo *blend = info->pColorBlendState; + if (!blend || !blend->pAttachments || !blend->attachmentCount) + return; + rw->attachments = malloc(blend->attachmentCount * sizeof(*rw->attachments)); + memcpy(rw->attachments, blend->pAttachments, blend->attachmentCount * sizeof(*rw->attachments)); + bool changed = false; + for (uint32_t i = 0; i < blend->attachmentCount; i++) { + VkPipelineColorBlendAttachmentState *a = &rw->attachments[i]; + changed |= single_source_equation(&a->srcColorBlendFactor, &a->dstColorBlendFactor, &a->srcAlphaBlendFactor, + &a->dstAlphaBlendFactor); + } + if (!changed) { + free(rw->attachments); + rw->attachments = NULL; + return; + } + rw->blend = *blend; + rw->blend.pAttachments = rw->attachments; +} + static void rewrite_pipeline(struct device *dev, VkGraphicsPipelineCreateInfo *info, struct pipeline_rewrite *rw) { if ((dev->emulated & GAP_FILL_MODE) && info->pRasterizationState && @@ -241,7 +324,12 @@ static void rewrite_pipeline(struct device *dev, VkGraphicsPipelineCreateInfo *i rw->viewport.scissorCount = 1; info->pViewportState = &rw->viewport; } - if (dev->emulated & GAPS_SHADER) + if (dev->emulated & GAP_DUAL_SRC_BLEND) { + rewrite_blend(info, rw); + if (rw->attachments) + info->pColorBlendState = &rw->blend; + } + if (dev->emulated & (GAPS_SHADER | GAP_DUAL_SRC_BLEND)) rewrite_shaders(dev, info, rw); } @@ -257,7 +345,9 @@ static void undo_rewrite(struct device *dev, struct pipeline_rewrite *rw) if (rw->temporary[i] != VK_NULL_HANDLE) dev->DestroyShaderModule(dev->handle, rw->temporary[i], NULL); free(rw->code[i].words); + free(rw->single[i].words); } + free(rw->attachments); } VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipelineCache cache, uint32_t count, @@ -306,3 +396,15 @@ VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount(VkCommandBuffer cmd, uint32_t struct device *dev = device_from_handle(cmd); dev->CmdSetScissorWithCount(cmd, count > 1 ? 1 : count, scissors); } + +VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT(VkCommandBuffer cmd, uint32_t first, uint32_t count, + const VkColorBlendEquationEXT *equations) +{ + struct device *dev = device_from_handle(cmd); + for (uint32_t i = 0; i < count; i++) { + VkColorBlendEquationEXT equation = equations[i]; + single_source_equation(&equation.srcColorBlendFactor, &equation.dstColorBlendFactor, + &equation.srcAlphaBlendFactor, &equation.dstAlphaBlendFactor); + dev->CmdSetColorBlendEquationEXT(cmd, first + i, 1, &equation); + } +} diff --git a/tools/venus/layer/spirv.c b/tools/venus/layer/spirv.c index 734d5ce2d9..9a9794d9ce 100644 --- a/tools/venus/layer/spirv.c +++ b/tools/venus/layer/spirv.c @@ -416,19 +416,19 @@ static void add_to_interface(struct module *m, uint32_t id) } /* A standalone distance variable becomes Private, and its decorations go. */ -static void privatize(struct module *m, const struct distance_var *var) +static void privatize(struct module *m, uint32_t id) { - size_t d = definition(m, var->id); + size_t d = definition(m, id); uint32_t storage, pointee; pointer_parts(m, m->w[d + 1], &storage, &pointee); m->w[d + 1] = pointer_type(m, SpvStorageClassPrivate, pointee); m->w[d + 3] = SpvStorageClassPrivate; - mark_private(m, var->id); + mark_private(m, id); /* Before SPIR-V 1.4 an entry point lists only its inputs and outputs. */ if (m->version < VERSION_1_4) - m->interface_remove[var->id] = 1; + m->interface_remove[id] = 1; for (size_t i = 5; i < m->first_declaration; i += LENGTH(m->w[i])) { - if (OPCODE(m->w[i]) == SpvOpDecorate && m->w[i + 1] == var->id) + if (OPCODE(m->w[i]) == SpvOpDecorate && m->w[i + 1] == id) edit(m, i, INSTEAD); } } @@ -667,7 +667,7 @@ static void strip(struct module *m, const struct analysis *a, uint32_t keep) { for (uint32_t i = 0; i < a->var_count; i++) { if (a->vars[i].id != keep) - privatize(m, &a->vars[i]); + privatize(m, a->vars[i].id); } struct stand_in stand_ins[16]; uint32_t count = make_stand_ins(m, a, stand_ins, 16); @@ -688,6 +688,50 @@ bool spirv_strip_distances(const uint32_t *words, size_t count, struct spirv_cod return done; } +static bool is_second_source(const uint32_t *w) +{ + return OPCODE(w[0]) == SpvOpDecorate && LENGTH(w[0]) == 4 && w[2] == SpvDecorationIndex && w[3] == 1; +} + +bool spirv_uses_dual_source(const uint32_t *words, size_t count) +{ + if (count <= 5 || words[0] != SpvMagicNumber) + return false; + for (size_t i = 5; i < count && LENGTH(words[i]) && i + LENGTH(words[i]) <= count; i += LENGTH(words[i])) { + if (is_declaration(OPCODE(words[i]))) + break; + if (is_second_source(&words[i])) + return true; + } + return false; +} + +bool spirv_strip_dual_source(const uint32_t *words, size_t count, struct spirv_code *out) +{ + struct module m; + if (!load(&m, words, count)) + return false; + uint32_t outputs[8]; + uint32_t output_count = 0; + for (size_t i = 5; i < m.first_declaration; i += LENGTH(m.w[i])) { + if (!is_second_source(&m.w[i])) + continue; + size_t d = definition(&m, m.w[i + 1]); + uint32_t storage, pointee; + if (output_count == 8 || !d || OPCODE(m.w[d]) != SpvOpVariable || + !pointer_parts(&m, m.w[d + 1], &storage, &pointee) || storage != SpvStorageClassOutput) + m.failed = true; + else + outputs[output_count++] = m.w[i + 1]; + } + for (uint32_t i = 0; i < output_count && !m.failed; i++) + privatize(&m, outputs[i]); + retarget_accesses(&m, NULL, 0); + bool done = finish(&m, out); + unload(&m); + return done; +} + static const struct distance_var *clip_output(const struct module *m, const struct analysis *a, uint32_t *length) { for (uint32_t i = 0; i < a->var_count; i++) { diff --git a/tools/venus/release.env b/tools/venus/release.env index 5da556c28b..91603af626 100644 --- a/tools/venus/release.env +++ b/tools/venus/release.env @@ -1,3 +1,3 @@ -VENUS_REPO=The412Banner/droiddeck-nonadreno-drivers -VENUS_TAG=venus-proto13-e24ed8ab -VENUS_SHA256=25f236bbc32c8490fc61c20a6016b0bea4a8c3267a69de6b91496da2afe6bc04 +VENUS_REPO=Droid-Deck/DroidDeck-Components +VENUS_TAG=venus-dualsrc-463ba9ef +VENUS_SHA256=ace6f4c3e62db0c7487859d8cebdcdd83656272951f84c00471fafc364ae30af diff --git a/tools/xbox/README.md b/tools/xbox/README.md index 986fc1bd75..73afef3803 100644 --- a/tools/xbox/README.md +++ b/tools/xbox/README.md @@ -41,6 +41,12 @@ app's credential socket (`NEXUS_CREDENTIAL_ERROR_V1 socket-refused`, `-denied`, uses a keyed loopback port the app also listens on; some devices refuse the abstract socket from inside PRoot. The key is passed in the backend's environment only. +`droiddeck-licensing-device-ticket.patch` sends a delegation-compact device ticket to content +licensing and Store license tokens in the licensing wire form (`t=` or a bare compact JWE), as +user tickets already are. A plain compact device ticket is sent unchanged. The rule follows +[@domsvoboda](https://github.com/domsvoboda)'s nexus-backend commit `27c335e` and +xodus-gaming/xodus#238. + `droiddeck-credential-diagnostics.patch` names the step behind a `credential-io` failure: the session lock (`lock-dir-owner`, `lock-file-mode`, `lock-flock-`, ...), a socket or loopback exchange that broke after connecting (`socket-exchange-`), a malformed host reply, or a diff --git a/tools/xbox/droiddeck-licensing-device-ticket.patch b/tools/xbox/droiddeck-licensing-device-ticket.patch new file mode 100644 index 0000000000..ffd5edbfa9 --- /dev/null +++ b/tools/xbox/droiddeck-licensing-device-ticket.patch @@ -0,0 +1,136 @@ +diff --git a/crates/xodus-cli/src/license.rs b/crates/xodus-cli/src/license.rs +index 4518c22..5a12753 100644 +--- a/crates/xodus-cli/src/license.rs ++++ b/crates/xodus-cli/src/license.rs +@@ -58,6 +58,7 @@ pub async fn get_license( + let Token::Compact(ms_device_token) = ms_device_token else { + return Err("Unsupported token".to_string()); + }; ++ let ms_device_token = xodus::models::secrets::licensing_device_ticket(ms_device_token); + + let user_token: Token = match user_token { + ExchangeUserTokenOutcome::Fault(_) => { +diff --git a/crates/xodus-service/src/store_license.rs b/crates/xodus-service/src/store_license.rs +index e6b4c58..abede2e 100644 +--- a/crates/xodus-service/src/store_license.rs ++++ b/crates/xodus-service/src/store_license.rs +@@ -63,8 +63,7 @@ async fn issue(context: &SimpleContext, request: StoreLicenseTokenRequest) -> Re + let device_response = xodus::api::live::exchange_device_token(&context.client, device.clone(), + client_id.into(), "www.microsoft.com".into(), Some(soap::PolicyReference::mbi_ssl())) + .await.map_err(|_| FAIL)?; +- if device_response.token_type != "urn:passport:compact" { return Err(FAIL) } +- let Token::Compact(device_token) = Token::try_from(device_response).map_err(|_| FAIL)? else { return Err(FAIL) }; ++ let device_token = device_license_ticket(device_response)?; + let user_response = xodus::api::live::exchange_user_token(&context.client, user_sts, + account.username, device, None, Some("Silent".into()), client_id.into(), + &[("www.microsoft.com".into(), Some(soap::PolicyReference::mbi_ssl()))]) +@@ -98,6 +97,13 @@ async fn issue(context: &SimpleContext, request: StoreLicenseTokenRequest) -> Re + Ok(response.license_token) + } + ++fn device_license_ticket(response: soap::RequestSecurityTokenResponse) -> Result { ++ if !user_ticket_type(&response.token_type) { return Err(FAIL) } ++ let Token::Compact(ticket) = Token::try_from(response).map_err(|_| FAIL)? else { return Err(FAIL) }; ++ if ticket.is_empty() || ticket == "d=" { return Err(FAIL) } ++ Ok(xodus::models::secrets::licensing_device_ticket(ticket)) ++} ++ + fn user_ticket_type(token_type: &str) -> bool { + matches!(token_type, "urn:passport:compact" | "urn:passport:delegationcompact") + } +@@ -134,6 +140,45 @@ mod tests { + } + } + ++ fn device_response(kind: &str, value: Option<&str>) -> soap::RequestSecurityTokenResponse { ++ soap::RequestSecurityTokenResponse { ++ token_type: kind.into(), ++ applies_to: soap::AppliesTo { endpoint_reference: soap::EndpointReference { address: "synthetic.invalid".into() } }, ++ lifetime: soap::Timestamp { id: None, created: "2000-01-01T00:00:00Z".into(), expires: "2099-01-01T00:00:00Z".into() }, ++ requested_security_token: soap::RequestedSecurityToken { encrypted_data: None, ++ binary_security_token: value.map(|value| soap::BinarySecurityTokenRes { ++ id: "synthetic".into(), value: value.into(), value_type: None }) }, ++ requested_proof_token: None, ++ } ++ } ++ ++ #[test] ++ fn store_license_device_compact_tickets_are_sent_unchanged() { ++ let raw = "eyJhbGciOiJkaXIiLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0..aXY.Y2lwaGVy_dGV4dA.dGFn"; ++ for value in ["t=opaque-device&p=", "opaque-device", raw] { ++ assert_eq!(device_license_ticket(device_response("urn:passport:compact", Some(value))), Ok(value.to_string())); ++ } ++ } ++ ++ #[test] ++ fn store_license_device_delegation_tickets_use_the_licensing_wire_form() { ++ let raw = "eyJhbGciOiJkaXIiLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0..aXY.Y2lwaGVy_dGV4dA.dGFn"; ++ assert_eq!(device_license_ticket(device_response("urn:passport:delegationcompact", Some(raw))), Ok(raw.to_string())); ++ assert_eq!(device_license_ticket(device_response("urn:passport:delegationcompact", Some("opaque-device"))), ++ Ok("t=opaque-device".to_string())); ++ } ++ ++ #[test] ++ fn store_license_device_unknown_missing_and_empty_tickets_fail_closed() { ++ for kind in ["urn:passport:legacy", "urn:passport:unknown"] { ++ assert_eq!(device_license_ticket(device_response(kind, Some("opaque-device"))), Err(FAIL)); ++ } ++ for kind in ["urn:passport:compact", "urn:passport:delegationcompact"] { ++ assert_eq!(device_license_ticket(device_response(kind, None)), Err(FAIL)); ++ assert_eq!(device_license_ticket(device_response(kind, Some(""))), Err(FAIL)); ++ } ++ } ++ + fn request(ids: &[&str]) -> StoreLicenseTokenRequest { + StoreLicenseTokenRequest { parent_product_id: "9N4PT8HGCDHQ".into(), + product_ids: ids.iter().map(|s| s.to_string()).collect(), custom_developer_string: "nonce<&>".into() } +diff --git a/crates/xodus/src/models/licensing_ticket_tests.rs b/crates/xodus/src/models/licensing_ticket_tests.rs +index 10ff57e..6db9ff1 100644 +--- a/crates/xodus/src/models/licensing_ticket_tests.rs ++++ b/crates/xodus/src/models/licensing_ticket_tests.rs +@@ -1,5 +1,5 @@ + //! Public synthetic data only, no account, keyring or network access. +-use super::{Token, licensing_ticket, store_ticket, xbox_ticket}; ++use super::{Token, licensing_device_ticket, licensing_ticket, store_ticket, xbox_ticket}; + use crate::models::soap; + use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD}; + use serde_json::json; +@@ -109,3 +109,23 @@ fn credential_xbox_ticket_opaque_and_malformed_tokens_are_preserved() { + } + for ticket in cases { assert_eq!(xbox_ticket(ticket.clone()), ticket); } + } ++ ++#[test] ++fn credential_licensing_device_ticket_delegation_forms_use_the_licensing_wire_form() { ++ for raw in [ ++ jwe(json!({"alg":"dir","enc":"A128CBC-HS256"}), ""), ++ jwe(json!({"alg":"RSA-OAEP-256","enc":"A256GCM"}), "a2V5"), ++ ] { ++ let Token::Compact(original) = delegation(&raw) else { panic!("fixture"); }; ++ assert_eq!(licensing_device_ticket(original), raw); ++ } ++ assert_eq!(licensing_device_ticket("d=opaque-device".into()), "t=opaque-device"); ++} ++ ++#[test] ++fn credential_licensing_device_ticket_plain_compact_forms_stay_byte_exact() { ++ let raw = jwe(json!({"alg":"dir","enc":"A256GCM"}), ""); ++ for ticket in ["t=opaque-device&p=".to_string(), "opaque-device".into(), "".into(), raw.clone(), format!("t={raw}")] { ++ assert_eq!(licensing_device_ticket(ticket.clone()), ticket); ++ } ++} +diff --git a/crates/xodus/src/models/secrets.rs b/crates/xodus/src/models/secrets.rs +index 1ad97be..9de6eea 100644 +--- a/crates/xodus/src/models/secrets.rs ++++ b/crates/xodus/src/models/secrets.rs +@@ -102,6 +102,10 @@ pub fn licensing_ticket(ticket: String) -> String { + if is_compact_jwe(bare) { bare.to_string() } else { store_ticket(ticket) } + } + ++pub fn licensing_device_ticket(ticket: String) -> String { ++ if ticket.starts_with("d=") { licensing_ticket(ticket) } else { ticket } ++} ++ + // This recognizes wire encoding, not authenticity or entitlement. Microsoft + // still validates the entire ticket. Never decrypt, log or rewrite its payload. + fn is_compact_jwe(value: &str) -> bool { diff --git a/tools/xbox/prepare.py b/tools/xbox/prepare.py index ef2b230245..222b887606 100755 --- a/tools/xbox/prepare.py +++ b/tools/xbox/prepare.py @@ -9,7 +9,8 @@ recipe = Path(__file__).resolve().parent cache = Path(sys.argv[1]).resolve() lock = json.loads((recipe / 'backend.lock.json').read_text()) local_patches = ['droiddeck-credentials.patch', 'droiddeck-launch-view.patch', 'droiddeck-library-subscriptions.patch', - 'droiddeck-credential-fallback.patch', 'droiddeck-credential-diagnostics.patch', 'droiddeck-cloud-token.patch', 'droiddeck-xbox-ticket.patch'] + 'droiddeck-credential-fallback.patch', 'droiddeck-credential-diagnostics.patch', 'droiddeck-cloud-token.patch', 'droiddeck-xbox-ticket.patch', + 'droiddeck-licensing-device-ticket.patch'] identity = hashlib.sha256((recipe / 'backend.lock.json').read_bytes() + b''.join((recipe / name).read_bytes() for name in local_patches)).hexdigest() source = cache / ('source-' + identity[:16]) if not (source / '.prepared').is_file(): diff --git a/tools/xbox/runtime.lock.json b/tools/xbox/runtime.lock.json index eb3042fa45..e99520de78 100644 --- a/tools/xbox/runtime.lock.json +++ b/tools/xbox/runtime.lock.json @@ -14,5 +14,15 @@ "xgameruntime.dll": "060120e0ec6bccfbab516128315a0658b11d3e316f62a917c653daf1a1dd3e05", "winhttp.dll": "81e1da7a731d83fbd24dbe2fa2ecb8f155bd477a9f9b6f4cc3932063cc326c27", "wintypes.dll": "7d06083e3d8b3a7e11555a91e7918f11c7d444a74755d41c8d1990db3697c895" + }, + "compat": { + "files/share/xodus-nexus/compat/PlayFabGameSave.dll": [ + "compat/PlayFabGameSave.dll", + "29b1ab5e54b35e40ee5b376237f4ab642e1d0f3d7614e3e46208e9ad8a6e0a79" + ], + "files/share/doc/xodus-nexus-runtime/runtime-compat-LICENSE": [ + "LICENSE.runtime-compat", + "639b735fd2f65779b82c4aab471f1fcdf927e10e1c21250911f75d44d136ff11" + ] } } diff --git a/tools/xbox/runtime.py b/tools/xbox/runtime.py index 38bb102395..2cafe4a592 100755 --- a/tools/xbox/runtime.py +++ b/tools/xbox/runtime.py @@ -37,8 +37,22 @@ archive = download(lock['archive'], lock['sha512'], 'sha512') source = lock['source'] download(source['name'], source['sha256'], 'sha256') remaining = set(lock['dlls']) +# Prebuilt runtime-compat files from the same archive (MIT), placed next to windows/ in the pack: the +# PlayFab Game Saves save-folder proxy that droiddeck-xbox stages in front of a title's SDK, and its license. +compat = dict(lock.get('compat', {})) with tarfile.open(archive) as tar: for member in tar: + relative = member.name.partition('/')[2] + if relative in compat: + target, expected = compat.pop(relative) + if not member.isfile() or member.size > 32 * 1024 * 1024: + raise RuntimeError('Invalid Xbox runtime compatibility file') + data = tar.extractfile(member).read() + if hashlib.sha256(data).hexdigest() != expected: + raise RuntimeError('Xbox runtime compatibility file checksum mismatch') + (output.parent / target).parent.mkdir(parents=True, exist_ok=True) + (output.parent / target).write_bytes(data) + continue name = Path(member.name).name if '/files/lib/wine/x86_64-windows/' not in member.name or name not in remaining: continue @@ -53,3 +67,5 @@ with tarfile.open(archive) as tar: remaining.remove(name) if remaining: raise RuntimeError('Missing Xbox runtime modules') +if compat: + raise RuntimeError('Missing Xbox runtime compatibility files')