diff --git a/.gitattributes b/.gitattributes index 53fa6915cf..3cb68a29e1 100644 --- a/.gitattributes +++ b/.gitattributes @@ -2,3 +2,11 @@ tools/linuxfs/** text=auto eol=lf tools/mangoapp/** text=auto eol=lf tools/comet/LICENSE whitespace=-blank-at-eof tools/comet/droiddeck.patch whitespace=-blank-at-eol,-blank-at-eof + +# These helpers are packaged verbatim and executed inside the Linux runtime. +tools/linuxfs/overlay/** text eol=lf +tools/linuxfs/desktop/** text eol=lf +tools/mangoapp/mangoapp text eol=lf +app/src/main/assets/desktop-removal/*.json text eol=lf +app/src/main/assets/desktop-removal/*.txt text eol=lf +*.pdf binary diff --git a/.github/workflows/build-fex.yml b/.github/workflows/build-fex.yml new file mode 100644 index 0000000000..8ec3369a1a --- /dev/null +++ b/.github/workflows/build-fex.yml @@ -0,0 +1,49 @@ +name: Build FEX (x86-64 Steam client) + +# Checks tools/fex: the same build DroidDeck-Components' build-fex.yml runs from this repository to publish FEX +# (its single `fex` release and fex.json, which the app follows). Nothing is published from here. + +on: + push: + paths: + - 'tools/fex/**' + - '.github/workflows/build-fex.yml' + workflow_dispatch: + inputs: + thunks: + description: 'Build the host thunks (Vulkan/GL/X11/... to the runtime arm64 libraries)' + required: false + default: 'false' + cxxflags: + description: 'Extra CXXFLAGS for a diagnostic build (e.g. -DDEBUG_STRACE)' + required: false + default: '' + +permissions: + contents: read + +jobs: + build: + runs-on: ubuntu-24.04-arm + timeout-minutes: 120 + steps: + - uses: actions/checkout@v4 + with: + persist-credentials: false + - name: Build in Arch Linux ARM + # Inputs reach the shell as environment variables, never pasted into the script. + env: + FEX_EXTRA_CXXFLAGS: ${{ inputs.cxxflags }} + FEX_THUNKS: ${{ inputs.thunks == 'true' && '1' || '0' }} + run: | + set -euo pipefail + docker run --rm -e FEX_EXTRA_CXXFLAGS="$FEX_EXTRA_CXXFLAGS" -e FEX_THUNKS="$FEX_THUNKS" -v "$PWD:/work" -w /work menci/archlinuxarm:base-devel bash tools/fex/build-in-arch.sh + sudo chown -R "$(id -u):$(id -g)" . + - uses: actions/upload-artifact@v4 + with: + name: fex + path: | + fex.tzst + fex.tzst.sha256 + fex-needed.txt + fex-files.txt diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 4fcdca0261..775555696c 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -26,7 +26,7 @@ concurrency: cancel-in-progress: ${{ github.event_name == 'pull_request' }} env: - PRELOAD_CACHE_VERSION: v3 + PRELOAD_CACHE_VERSION: v6 jobs: build: @@ -193,7 +193,7 @@ jobs: run: | set -euo pipefail sudo apt-get update -qq - sudo apt-get install -y -qq gcc-aarch64-linux-gnu g++-aarch64-linux-gnu libvulkan-dev >/dev/null + sudo apt-get install -y -qq gcc-aarch64-linux-gnu g++-aarch64-linux-gnu libvulkan-dev libvulkan1 mesa-vulkan-drivers >/dev/null D=app/src/main/assets/linuxfs mkdir -p "$D" aarch64-linux-gnu-g++ -shared -fPIC -O2 -Wall -Wno-attributes -Wno-nonnull-compare \ @@ -321,9 +321,15 @@ jobs: set -euo pipefail docker run --rm -v "$PWD:/src" -w /src public.ecr.aws/docker/library/debian:bullseye bash -c ' set -euo pipefail - printf "deb http://archive.debian.org/debian bullseye main\ndeb http://archive.debian.org/debian-security bullseye-security main\n" > /etc/apt/sources.list - apt-get -o Acquire::Check-Valid-Until=false update -qq - DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends gcc g++ gcc-multilib g++-multilib binutils >/dev/null + install_compilers() { + apt-get -o Acquire::Check-Valid-Until=false update -qq && + DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends gcc g++ gcc-multilib g++-multilib binutils >/dev/null + } + printf "deb http://deb.debian.org/debian bullseye main\ndeb http://security.debian.org/debian-security bullseye-security main\n" > /etc/apt/sources.list + if ! install_compilers; then + printf "deb http://archive.debian.org/debian bullseye main\ndeb http://archive.debian.org/debian-security bullseye-security main\n" > /etc/apt/sources.list + install_compilers + fi tools/linuxfs/build-x86-preloads.sh app/src/main/assets/linuxfs ' sudo chown -R "$(id -u):$(id -g)" app/src/main/assets/linuxfs @@ -428,6 +434,30 @@ jobs: test -f app/src/main/assets/venus/libvulkan_virtio.so rm venus.tzst + - name: Check Quest tracking IPC + run: | + set -euo pipefail + NDK="${ANDROID_NDK_LATEST_HOME:-${ANDROID_NDK_HOME:-$ANDROID_NDK_ROOT}}" + VK_INCLUDE=$(ls -d "$NDK"/toolchains/llvm/prebuilt/*/sysroot/usr/include | head -1) + mkdir -p build/vr/include + cp -R "$VK_INCLUDE/vulkan" build/vr/include/ + if [ -d "$VK_INCLUDE/vk_video" ]; then cp -R "$VK_INCLUDE/vk_video" build/vr/include/; fi + g++ -std=c++17 -Wall -Wextra -Werror -pthread tools/vr/tests/test_xr_tracking.cpp -o /tmp/test-xr-tracking + /tmp/test-xr-tracking + g++ -std=c++17 -Wall -Wextra -Werror tools/vr/tests/test_xr_touch.cpp -o /tmp/test-xr-touch + /tmp/test-xr-touch + g++ -std=c++17 -Wall -Wextra -Werror -pthread tools/vr/tests/test_xr_vsync.cpp -o /tmp/test-xr-vsync + /tmp/test-xr-vsync + g++ -std=c++17 -Wall -Wextra -Werror -pthread tools/vr/tests/test_xr_frames.cpp -o /tmp/test-xr-frames + /tmp/test-xr-frames + cc -Itools/vr/third_party/wayland -c tools/vr/src/wayland_client_stub.c -o /tmp/test-wayland-stub.o + cc -Itools/vr/third_party/wayland -c app/src/main/cpp/waylandcomp/generated/xdg-shell-protocol.c -o /tmp/test-xdg-shell.o + g++ -std=c++17 -Wall -Wextra -Werror -Wno-unused-parameter -Wno-missing-field-initializers -pthread -Ibuild/vr/include \ + -Itools/vr/third_party/wayland -Iapp/src/main/cpp/waylandcomp/generated \ + tools/vr/tests/test_presenter_shutdown.cpp tools/vr/src/presenter.cpp /tmp/test-wayland-stub.o /tmp/test-xdg-shell.o \ + -ldl -o /tmp/test-presenter-shutdown + timeout 10 /tmp/test-presenter-shutdown + - name: Rust toolchain for the store engines (aarch64-linux-android) id: rust run: | @@ -461,7 +491,7 @@ jobs: path: | app/.cxx app/build/intermediates/cxx - key: cxx-${{ env.NDK_VERSION }}-${{ hashFiles('app/src/main/cpp/**') }} + key: cxx-${{ env.NDK_VERSION }}-${{ hashFiles('app/src/main/cpp/**', 'tools/vr/src/xr_*.h') }} restore-keys: | cxx-${{ env.NDK_VERSION }}- @@ -518,7 +548,24 @@ jobs: python3 -m unittest discover -s tools/tests -p 'test_*.py' - name: Unit tests - run: ./gradlew testReleaseUnitTest --console=plain -PndkVersion="$NDK_VERSION" + id: unit-tests + run: | + set -o pipefail + mkdir -p app/build + ./gradlew testReleaseUnitTest --console=plain --info --stacktrace -Drobolectric.logging=stderr -PndkVersion="$NDK_VERSION" 2>&1 | tee app/build/unit-tests.log + + - name: Upload unit test diagnostics + id: unit-test-diagnostics + if: always() && steps.unit-tests.outcome != 'skipped' + uses: actions/upload-artifact@v4 + with: + name: unit-test-results + path: | + app/build/unit-tests.log + app/build/test-results/testReleaseUnitTest/ + app/build/reports/tests/testReleaseUnitTest/ + if-no-files-found: ignore + retention-days: 14 - name: Sign with the testkey (v1 + v2 + v3) run: | @@ -548,6 +595,15 @@ jobs: grep -qi "CN=Android, OU=Android, O=Android" /tmp/sig.txt \ || { echo "::error::apk is not signed with the AOSP testkey"; exit 1; } + - uses: actions/upload-artifact@v4 + id: apk-upload + with: + name: droiddeck-apk + path: app/build/outputs/apk/release/*.apk + if-no-files-found: error + retention-days: 30 + compression-level: 0 + - name: Report on the pull request if: always() && github.event_name == 'pull_request' continue-on-error: true @@ -556,6 +612,9 @@ jobs: PR: ${{ github.event.pull_request.number }} RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }} BUILD_OUTCOME: ${{ steps.build.outcome }} + UNIT_TEST_OUTCOME: ${{ steps.unit-tests.outcome }} + TEST_DIAGNOSTICS_URL: ${{ steps.unit-test-diagnostics.outputs.artifact-url }} + APK_OUTCOME: ${{ steps.apk-upload.outcome }} SAME_REPO: ${{ github.event.pull_request.head.repo.full_name == github.repository }} run: | set -uo pipefail @@ -566,8 +625,8 @@ jobs: echo [ -f /tmp/pr-merge.md ] && cat /tmp/pr-merge.md echo - case "$BUILD_OUTCOME" in - success) + case "$BUILD_OUTCOME:$UNIT_TEST_OUTCOME:$APK_OUTCOME" in + success:success:success) echo "### Build passed" echo echo "The \`droiddeck-apk\` artifact is [on this run]($RUN_URL), signed with the public test key." @@ -580,7 +639,28 @@ jobs: echo echo "Fallback: [open **PR Release Publish**]($GITHUB_SERVER_URL/$GITHUB_REPOSITORY/actions/workflows/pr-release-publish.yml) on \`main\` and enter PR \`$PR\`." ;; - failure) + success:success:*) + echo "### APK publication incomplete" + echo + echo "Compilation and unit tests passed, but APK publication did not complete. See [the run]($RUN_URL)." + ;; + success:failure:*) + echo "### ERROR: Unit tests failed" + echo + echo "The APK compiled, but unit tests failed. No installable artifact was published." + echo + if [ -n "$TEST_DIAGNOSTICS_URL" ]; then + echo "The [unit-test-results]($TEST_DIAGNOSTICS_URL) artifact contains the test log and any generated reports." + else + echo "The test diagnostics upload did not complete. See [the test log]($RUN_URL)." + fi + ;; + success:*) + echo "### Build incomplete" + echo + echo "The APK compiled, but unit tests did not complete successfully. See [the run]($RUN_URL)." + ;; + failure:*) echo "### ERROR: Build failed" echo echo "The compiler's errors ([full log]($RUN_URL)):" @@ -598,7 +678,7 @@ jobs: echo '```' echo "" ;; - skipped|cancelled) + skipped:*|cancelled:*) echo "### Not built" echo echo "The build did not run (see above, or [the run]($RUN_URL))." @@ -614,14 +694,6 @@ jobs: gh api -X POST "repos/${GITHUB_REPOSITORY}/issues/${PR}/comments" -F body=@/tmp/pr-report.md >/dev/null fi - - uses: actions/upload-artifact@v4 - with: - name: droiddeck-apk - path: app/build/outputs/apk/release/*.apk - if-no-files-found: error - retention-days: 30 - compression-level: 0 - sign: needs: build if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main' diff --git a/README.md b/README.md index ba921398cb..6261459dfd 100644 --- a/README.md +++ b/README.md @@ -15,10 +15,14 @@ DroidDeck brings the SteamOS experience to Android: Valve's Steam client in Big ## Requirements and install -Use Android 9 or newer. Supported Adreno devices include 730 or newer, or 8xx. Adreno 6xx is experimental: DirectX 11 uses DXVK 2 and may run, and DirectX 12 games can still crash. PowerVR support is experimental: where the system Vulkan backend is available, the app selects it automatically. Mali, Xclipse, and Adreno 710 are unsupported. No root is required. Allow about 3 GB for the runtime and 1.1 GB more for the desktop and emulators. Install the APK from [Releases](https://github.com/Droid-Deck/DroidDeck/releases), install the Linux runtime, then press **Play** and sign in. Steam downloads on first launch. Install **Desktop & apps** to use the desktop and emulators. The **Store** installs Linux apps and games from Flathub (ARM64 builds) with Flatpak; with additional options to install Appimages and set up scripts. **Stores** (Setup › Stores › "Show Stores in the rail") signs in to GOG, Epic Games and Amazon Games, browses their catalogs and libraries, downloads games into the Games storage and adds each one to the Steam client as a non-Steam game, so it launches through Proton like everything else; the cog on its chip row sets which tab a store opens on and the download speed tier. +Use Android 9 or newer on a supported Adreno device (730 or newer, or 8xx). Adreno 6xx is experimental: DirectX 11 uses DXVK 2 and may run, and DirectX 12 games can still crash. PowerVR support is experimental: where the system Vulkan backend is available, the app selects it automatically. Mali, Xclipse, and Adreno 710 are unsupported in official builds; this non-Adreno test build adds experimental routes for them. No root is required. Allow about 3 GB for the runtime and 1.1 GB more for the desktop and emulators. Install the APK from [Releases](https://github.com/Droid-Deck/DroidDeck/releases), install the Linux runtime, then press **Play** and sign in. Steam downloads on first launch. Install **Desktop & apps** to use the desktop and emulators. The **Store** installs Linux apps and games from Flathub (ARM64 builds) with Flatpak; with additional options to install Appimages and set up scripts. **Stores** (Setup › Stores › "Show Stores in the rail") signs in to GOG, Epic Games and Amazon Games and downloads games into the Games storage. Epic keeps its direct API install path. Opening Epic Stores prepares Epic’s official Linux launcher preview. When installed, Epic games launched from DroidDeck use that client, and games installed in the client are imported into DroidDeck’s library and shortcuts. The x86-64 client runs through FEX on ARM and DroidDeck retains its Proton hooks; this preview and ARM setup are outside Epic’s listed Linux support. The cog on a store’s chip row sets its opening tab and download speed tier. On Android 14 and newer, before Steam launches, you must turn on **Disable child process restrictions** in Developer options. If this option is not available in developer settings (Android 12 and 13 devices), first launch of Steam will present a "Fix it for me" button, which will help automate the setup process. +## Smart glasses + +Use **Setup → Smart glasses** for app-wide virtual-screen settings across DroidDeck menus, launchers, desktop sessions, and games. Supported VITURE, RayNeo, and XREAL connections provide 3DoF; Luma Ultra adds optional experimental 6DoF and stereo-assisted hand/Joy-Con tracking. Model support and SDK requirements differ: see the [smart-glasses support matrix](docs/smart-glasses-support.md) for supported devices, controls, setup, and limitations. + ## Community Join the [DroidDeck Discord](https://discord.gg/JRGAvawjsm) for help, Preview builds, and device reports. Bug reports go in its **#bug-reports** forum; attach the zip from **Share logs** (Setup, or the session drawer) so the logs come with it. @@ -29,6 +33,12 @@ Run `tools/build_local.sh` with Docker, Java 17, the Android SDK/NDK, Rust throu After preparation, ordinary `./gradlew :app:assembleRelease` builds can reuse the verified inputs. If native sources, component pins or staged files change, packaging stops with instructions to rerun the helper. Generated audio stays under `app/build/`; the tracked base bundle is never modified. `./gradlew -PskipRust=true :app:testDebugUnitTest` needs no native preparation. For an APK without store engines, use `DROIDDECK_SKIP_RUST=1 tools/build_local.sh`; it omits cached engine libraries too. +For the prepared Windows checkout, run `./tools/run_windows.ps1` (optionally with `-Serial `), or select **DroidDeck XR** in Android Studio and run the **app** module on the connected phone. Machine-specific options live in the ignored `local.properties`: `droiddeck.python` selects a Python executable, `droiddeck.skipRust=true` omits the optional store download engines, and `droiddeck.debugApplicationIdSuffix=.xr` installs **DroidDeck XR Dev** alongside the signed release. The development app has its own runtime and Steam login. The local Java selection is in `.gradle/config.properties`. + +`python tools/prepare_windows_runtime.py` restores this checkout's audited runtime inputs from the pinned CI APK, three locally rebuilt preload libraries, and the checksum-pinned Gamescope archive in `build/windows-setup/`. Start Docker Desktop's Linux engine first: preparation now rebuilds DroidDeck's ARM64 VR driver and Vulkan layer from current source and runs their native regression tests. The compiler image is built automatically on first use. Vulkan headers come from the NDK beside `--llvm-strip`, or from an explicit `--vk-include ` directory. + +To reuse that build, pass `--rebuilt-vr build/windows-setup/vr`. Preparation verifies its `vr-build.json` against the current Git revision, source files, Vulkan headers, output checksums, and ARM64 architecture; missing or stale builds fail instead of falling back to the donor's VR libraries. The script checks the actual donor CI merge tree, still rejects unrelated unaudited runtime changes, and records component provenance in `app/build/windows-runtime-provenance.json`. Preserve these ignored preparation files when rebuilding locally; `clean` removes the prepared assets and their verification manifest. + Run the helper and preload regression suite with `bash tools/test_local.sh`. On macOS it runs in Linux through Docker, matching the helpers' runtime and CI instead of compiling Linux preloads against macOS headers. ## Limits @@ -37,4 +47,10 @@ Compatibility and performance vary by device; hardware validation is limited. De ## Credits and licence -GPL-3.0. Runtime, shim, input, and controller work build on WinNative and Bannerlator (maxjivi05). Epic Games and GOG support build on [Phobos’s](https://github.com/phobos665) adaptation of [Legendary](https://github.com/legendary-gl/legendary) and [gogdl](https://github.com/Heroic-Games-Launcher/heroic-gogdl), respectively. LSFG frame generation is from the work of Camille LaVey and the [Eden](https://eden-emu.dev) emulator project, following [lsfg-vk](https://github.com/PancakeTAS/lsfg-vk), ported to WinNative and DroidDeck by [@maxjivi05](https://github.com/maxjivi05); it needs your own copy of [Lossless Scaling](https://store.steampowered.com/app/993090/) and ships none of its shaders. x86 AppImages, and any whose own runtime cannot unpack them, are unpacked with [uruntime](https://github.com/VHSgunzo/uruntime) by VHSgunzo (MIT), shipped unmodified with its licence. See [LICENSE](LICENSE). Steam and Proton belong to Valve Corporation; this project is not affiliated with Valve. +GPL-3.0. Runtime, shim, input, and controller work build on WinNative and Bannerlator (maxjivi05). Epic Games and GOG support build on [Phobos’s](https://github.com/phobos665) adaptation of [Legendary](https://github.com/legendary-gl/legendary) and [gogdl](https://github.com/Heroic-Games-Launcher/heroic-gogdl), respectively. LSFG frame generation is from the work of Camille LaVey and the [Eden](https://eden-emu.dev) emulator project, following [lsfg-vk](https://github.com/PancakeTAS/lsfg-vk), ported to WinNative and DroidDeck by [@maxjivi05](https://github.com/maxjivi05); it needs your own copy of [Lossless Scaling](https://store.steampowered.com/app/993090/) and ships none of its shaders. x86 AppImages, and any whose own runtime cannot unpack them, are unpacked with [uruntime](https://github.com/VHSgunzo/uruntime) by VHSgunzo (MIT), shipped unmodified with its licence. mmap ring-buffer controller input was developed by ribbit384 ([WinNative #345](https://github.com/WinNative-Emu/WinNative/pull/345)). See [LICENSE](LICENSE). Steam and Proton belong to Valve Corporation; this project is not affiliated with Valve. + +XR glasses support builds on WinNative's VITURE glasses work. VITURE protocol details were checked against [XRLinuxDriver](https://github.com/wheaney/XRLinuxDriver) by [@wheaney](https://github.com/wheaney), including the VITURE protocol header it ships, [ar-drivers-rs](https://github.com/badicsalex/ar-drivers-rs) by [@badicsalex](https://github.com/badicsalex) and the [go-macos/iokit VITURE package](https://pkg.go.dev/github.com/go-macos/iokit/viture); the optional VITURE SDK belongs to VITURE and is not included. RayNeo support adapts [@informalTechCode](https://github.com/informalTechCode)'s [RayNeo-Air-Series-3DoF-Scaffold](https://github.com/informalTechCode/RayNeo-Air-Series-3DoF-Scaffold) (Apache-2.0) and references [@verncat](https://github.com/verncat)'s [RayNeo-Air-3S-Pro-OpenVR](https://github.com/verncat/RayNeo-Air-3S-Pro-OpenVR) (MIT) and [Monado](https://gitlab.freedesktop.org/monado/monado) (BSL-1.0); see [docs/third-party/rayneo](docs/third-party/rayneo/README.md). XREAL 1S support references [XRLinuxDriver](https://github.com/wheaney/XRLinuxDriver) and [xrealOneDeviceKit](https://github.com/wheaney/xrealOneDeviceKit) by @wheaney, [xreal_one_driver](https://github.com/rohitsangwan01/xreal_one_driver) by [@rohitsangwan01](https://github.com/rohitsangwan01) (MIT) and [xr-tools](https://github.com/0xcaff/xr-tools) by [@0xcaff](https://github.com/0xcaff). The REDMAGIC glasses-display findings draw on [@mekhontsev](https://github.com/mekhontsev)'s [MagicDesk investigation](https://github.com/mekhontsev/magicdesk/blob/main/docs/xr-resolution-fix.md) and [@Coding-BR](https://github.com/Coding-BR)'s [decompiled Nubia kernel](https://github.com/Coding-BR/android_kernel_nubia_sm8850_qwjujube). VITURE, RayNeo, XREAL and REDMAGIC are trademarks of their owners; this project is not affiliated with them. + +Joy-Con VR controllers port the arm model of Google's [Google VR SDK for Unity](https://github.com/googlevr/gvr-unity-sdk) (Apache-2.0), adapt the hand skeleton of Valve's [OpenVR](https://github.com/ValveSoftware/openvr) `handskeletonsimulation` sample (BSD-3-Clause), which follows Moshi Turner's hand simulation in [Monado](https://gitlab.freedesktop.org/monado/monado), and use the Index controller offsets from Monado's `vive_poses.c` (BSL-1.0). Joy-Con behaviour was researched in Linux's [hid-nintendo](https://github.com/torvalds/linux/blob/master/drivers/hid/hid-nintendo.c) driver by Daniel J. Ogorchock, [@dekuNukem](https://github.com/dekuNukem)'s [Nintendo_Switch_Reverse_Engineering](https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering), [SDL](https://github.com/libsdl-org/SDL) and the Android Open Source Project, and checked against [ALVR](https://github.com/alvr-org/ALVR), [OpenComposite](https://gitlab.com/znixian/OpenOVR), [PSMoveSteamVRBridge](https://github.com/HipsterSloth/PSMoveSteamVRBridge), [@F8LEFT](https://github.com/F8LEFT)'s [JoyConVr](https://github.com/F8LEFT/JoyConVr), [@krnelpan1c](https://github.com/krnelpan1c)'s [Daydream-Controller-SteamVR](https://github.com/krnelpan1c/Daydream-Controller-SteamVR), [@yoyobuae](https://github.com/yoyobuae)'s [joyconvr](https://github.com/yoyobuae/joyconvr), [Moonlight](https://github.com/moonlight-stream/moonlight-android) and [Dolphin](https://github.com/dolphin-emu/dolphin); see [docs/third-party/joycon](docs/third-party/joycon/README.md). Nintendo Switch and Joy-Con are trademarks of Nintendo; this project is not affiliated with Nintendo. + +Camera hand tracking runs Google's [MediaPipe](https://github.com/google-ai-edge/mediapipe) Tasks Vision library with its Pose Landmarker (Lite) model, BlazePose GHUM 3D, and its Hand Landmarker model (all Apache-2.0), on frames from AndroidX [CameraX](https://developer.android.com/jetpack/androidx/releases/camera) (Apache-2.0); MediaPipe's usage reports are switched off. The design was checked against [@F8LEFT](https://github.com/F8LEFT)'s [JoyConVr](https://github.com/F8LEFT/JoyConVr) camera app (MIT), and the short Joy-Con movements follow the accelerometer mode of the [Google VR SDK for Unity](https://github.com/googlevr/gvr-unity-sdk)'s arm model, Eric Foxlin's zero-velocity updates and Frosio, Pedersini and Borghese's accelerometer autocalibration, and the camera and Joy-Con are joined by a Kalman filter (R. E. Kalman, 1960). Bare camera hands take their gestures after [ALVR](https://github.com/alvr-org/ALVR)'s `hand_gestures.rs` (MIT) and Meta Quest's menu pinch, with distances checked on photos from the [HaGRID](https://github.com/hukenovs/hagrid) gesture set (CC BY-SA 4.0, not included), fit the palm with Horn's quaternion method (1987) and smooth it with the 1€ filter (Casiez, Roussel and Vogel, 2012); the white glove model follows Valve's OpenVR render model reference and Index controller poses, is meshed with surface nets (Gibson, 1998; Mikola Lysenko) and blends and shades it with Inigo Quilez's smooth minimum and distance-field ambient occlusion, porting his polygon distance (MIT); see [docs/third-party/handtracking](docs/third-party/handtracking/README.md). diff --git a/app/build.gradle b/app/build.gradle index 89c6fe0c42..dc0e395546 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -4,6 +4,32 @@ plugins { apply plugin: 'kotlin-android' apply plugin: 'org.jetbrains.kotlin.plugin.compose' +// Machine-specific tooling and optional CI-prepared inputs stay out of version control. +def localBuildOptions = new Properties() +def localBuildOptionsFile = rootProject.layout.projectDirectory.file('local.properties') +if (localBuildOptionsFile.asFile.exists()) { + localBuildOptions.load(new StringReader(providers.fileContents(localBuildOptionsFile).asText.get())) +} +def pythonExecutable = project.findProperty('pythonExecutable') + ?: localBuildOptions.getProperty('droiddeck.python', 'python3') +def vitureSdkDir = project.hasProperty('vitureSdkDir') ? project.property('vitureSdkDir') : localBuildOptions.getProperty('droiddeck.vitureSdk', '') +def uvcDir = project.hasProperty('uvcDir') ? project.property('uvcDir') : localBuildOptions.getProperty('droiddeck.uvcDir', '') +if (uvcDir) { + ['arm64-v8a/libusb.so', 'arm64-v8a/libuvc.a', 'include/libusb.h', 'include/libuvc/libuvc.h', + 'licenses/libusb-COPYING', 'licenses/libuvc-LICENSE.txt'].each { required -> + if (!new File(uvcDir, required).isFile()) throw new GradleException("Incomplete UVC build: missing ${required}") + } +} +if (vitureSdkDir) { + ['android/arm64-v8a/libglasses.so', 'android/arm64-v8a/libcarina_vio.so', + 'android/arm64-v8a/libcloud_protocol.so', 'include/viture_glasses_provider.h', + 'android/LICENSE', 'android/NOTICE'].each { required -> + if (!new File(vitureSdkDir, required).isFile()) { + throw new GradleException("Incomplete VITURE Android SDK: missing ${required}") + } + } +} + def gitValue = { List arguments -> try { def output = providers.exec { @@ -79,8 +105,8 @@ android { applicationId "com.droiddeck.launcher" minSdkVersion 26 targetSdkVersion 28 - versionCode 13 - versionName "0.4.0" + versionCode 14 + versionName "0.5.0" buildConfigField "String", "BUILD_LABEL", "\"${escapedBuildLabel}\"" buildConfigField "String", "SOURCE_COMMIT", "\"${sourceCommit}\"" buildConfigField "int", "PR_NUMBER", "${prNumber}" @@ -100,6 +126,8 @@ android { externalNativeBuild { cmake { arguments '-DANDROID_STL=c++_shared' + arguments "-DDROIDDECK_VITURE_SDK_DIR=${vitureSdkDir.toString().replace('\\', '/')}" + arguments "-DDROIDDECK_UVC_DIR=${uvcDir.toString().replace('\\', '/')}" } } } @@ -128,6 +156,11 @@ android { debug { minifyEnabled false signingConfig signingConfigs.testkey + def localSuffix = localBuildOptions.getProperty('droiddeck.debugApplicationIdSuffix') + if (localSuffix) { + applicationIdSuffix localSuffix + resValue 'string', 'app_name', 'DroidDeck XR Dev' + } } release { minifyEnabled false @@ -153,6 +186,7 @@ android { } buildFeatures { + prefab true compose true buildConfig true } @@ -160,6 +194,10 @@ android { testOptions { unitTests.returnDefaultValues = true unitTests.includeAndroidResources = true + unitTests.all { + def logTarget = providers.systemProperty('robolectric.logging').orNull + if (logTarget != null) systemProperty 'robolectric.logging', logTarget + } } compileOptions { @@ -171,6 +209,16 @@ android { } } +// Vendor binaries remain in the user's SDK directory; never vendor them into Git. +if (vitureSdkDir) { + android.sourceSets.main.jniLibs.srcDir(new File(vitureSdkDir, 'android')) + def stageVitureNotices = tasks.register('stageVitureNotices', Copy) { + from(new File(vitureSdkDir, 'android')) { include 'LICENSE', 'NOTICE' } + into(layout.buildDirectory.dir('vitureAssets/licenses/viture')) + } + tasks.named('preBuild').configure { dependsOn(stageVitureNotices) } +} + def stageSessionScripts = tasks.register('stageSessionScripts', Copy) { from(rootProject.file('tools/linuxfs/overlay')) { include 'usr/local/bin/droiddeck-*', 'usr/local/bin/steam-compatibility', 'usr/bin/**' @@ -187,12 +235,21 @@ def stageRuntimeAssets = tasks.register('stageRuntimeAssets', Sync) { into(runtimeAssetsDir) } android.sourceSets.main.assets.setSrcDirs([runtimeAssetsDir]) +if (vitureSdkDir) android.sourceSets.main.assets.srcDir(layout.buildDirectory.dir('vitureAssets')) +if (uvcDir) { + def stageUvcNotices = tasks.register('stageUvcNotices', Copy) { + from(new File(uvcDir, 'licenses')) + into(layout.buildDirectory.dir('uvcAssets/licenses/uvc')) + } + tasks.named('preBuild').configure { dependsOn(stageUvcNotices) } + android.sourceSets.main.assets.srcDir(layout.buildDirectory.dir('uvcAssets')) +} tasks.named('preBuild').configure { dependsOn(stageRuntimeAssets) } def verifyRuntimeInputs = tasks.register('verifyRuntimeInputs', Exec) { mustRunAfter(stageSessionScripts, stageRuntimeAssets) workingDir rootProject.projectDir - commandLine 'python3', 'tools/release/runtime_inputs.py', 'verify' + commandLine pythonExecutable, 'tools/release/runtime_inputs.py', 'verify' } tasks.configureEach { task -> if (task.name in ['packageDebug', 'packageRelease']) task.dependsOn(verifyRuntimeInputs) @@ -200,7 +257,8 @@ tasks.configureEach { task -> def rustCrateDir = layout.projectDirectory.dir('src/main/rust/stores') def rustJniLibsDir = layout.buildDirectory.dir('rustJniLibs') -def skipRust = (project.findProperty('skipRust') ?: 'false').toString().toBoolean() +def skipRust = (project.findProperty('skipRust') + ?: localBuildOptions.getProperty('droiddeck.skipRust', 'false')).toString().toBoolean() def buildRustStores = tasks.register('buildRustStores', Exec) { description = 'Cross-compiles the store download engines (libdroiddeckstores.so) with cargo-ndk.' onlyIf { !skipRust } @@ -244,8 +302,23 @@ def buildVkBridgeServer = tasks.register('buildVkBridgeServer', Exec) { } android.sourceSets.main.jniLibs.srcDir(vkbridgeJniLibsDir) tasks.named('preBuild').configure { dependsOn(buildVkBridgeServer) } +def verifyHandModel = tasks.register('verifyHandModel') { + def models = ['hand_landmarker.task': 'fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1', + 'hand_landmarker_lite.task': '173c0f47ecee7e935bd4a1e93aa580756b4180c1307c07d709313e82c28672c8'] + .collectEntries { name, hash -> [(file("src/main/assets/models/$name")): hash] } + inputs.files(models.keySet()) + doLast { + models.each { model, expected -> + def actual = java.security.MessageDigest.getInstance('SHA-256').digest(model.bytes).encodeHex().toString() + if (actual != expected) throw new GradleException("Hand Landmarker model checksum mismatch: ${model.name}") + } + } +} +tasks.named('preBuild').configure { dependsOn(verifyHandModel) } dependencies { + implementation 'org.opencv:opencv:4.13.0' + implementation 'org.khronos.openxr:openxr_loader_for_android:1.1.49' implementation 'com.github.luben:zstd-jni:1.5.7-4@aar' implementation 'org.apache.commons:commons-compress:1.27.1' implementation 'org.tukaani:xz:1.10' @@ -261,6 +334,11 @@ dependencies { implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3' implementation 'com.flyfishxu:kadb-android:1.2.1' implementation 'com.termux.termux-app:terminal-view:0.118.0' + implementation 'androidx.camera:camera-camera2:1.4.2' + implementation 'androidx.camera:camera-lifecycle:1.4.2' + implementation('com.google.mediapipe:tasks-vision:1.0.0') { + exclude group: 'com.google.auto.value', module: 'auto-value' + } testImplementation 'junit:junit:4.13.2' testImplementation 'org.robolectric:robolectric:4.16.1' diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 2320652d70..757d21bf84 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -1,5 +1,6 @@ - + @@ -19,13 +20,19 @@ + + + + + + + + + + + + + + + + + @@ -60,6 +84,7 @@ + @@ -106,7 +131,7 @@ android:name=".stores.StoreLoginActivity" android:exported="false" android:screenOrientation="sensorLandscape" - android:configChanges="orientation|screenSize|screenLayout|smallestScreenSize" + android:configChanges="orientation|screenSize|screenLayout|smallestScreenSize|density" android:theme="@style/AppTheme" /> + + + + + + diff --git a/app/src/main/assets/calibration/luma-ultra-640x480.json b/app/src/main/assets/calibration/luma-ultra-640x480.json new file mode 100644 index 0000000000..8136cdeebb --- /dev/null +++ b/app/src/main/assets/calibration/luma-ultra-640x480.json @@ -0,0 +1,102 @@ +{ + "version": 1, + "identity": "luma-ultra-base-v1", + "width": 640, + "height": 480, + "fisheye": false, + "error": 1.1209395390660726, + "verified": false, + "k1": { + "rows": 3, + "cols": 3, + "data": [ + 226.0499636040297, + 0, + 321.62348950766386, + 0, + 228.36987999988767, + 242.2674105020684, + 0, + 0, + 1 + ] + }, + "d1": { + "rows": 5, + "cols": 1, + "data": [ + -0.28622915867944043, + 0.1194613930041054, + 0.007984341063494766, + -0.0008220922923559441, + -0.025579805296512992 + ] + }, + "k2": { + "rows": 3, + "cols": 3, + "data": [ + 240.3338202496282, + 0, + 320.8790079027563, + 0, + 241.14047924325277, + 260.45566640784716, + 0, + 0, + 1 + ] + }, + "d2": { + "rows": 5, + "cols": 1, + "data": [ + -0.27073208928390136, + 0.08065508519805098, + -0.001460778493930769, + -0.0003694718992635806, + -0.011452505620454932 + ] + }, + "r": { + "rows": 3, + "cols": 3, + "data": [ + 0.900501479835182, + 0.04473903344740378, + -0.43254537762047496, + -0.08255720039597626, + 0.9941919046988283, + -0.06904176485356042, + 0.4269442510181227, + 0.0978819468416306, + 0.8989648107712929 + ] + }, + "t": { + "rows": 3, + "cols": 1, + "data": [ + -0.14117171913441395, + 0.0014051874404824838, + -0.007555740272006347 + ] + }, + "cameraToHead": [ + -0.05607918, + 0.023585627, + -0.07998472, + 0.01024512, + 0.9945703, + 0.005859665, + -0.10339546 + ], + "deviceModel": "VITURE Luma Ultra", + "cameraPair": "left0-right0", + "sourceValidation": { + "exportDate": "2026-10-16", + "sourceDeviceVerified": true, + "capturedViews": 25, + "scope": "Starting geometry from one calibrated Luma Ultra; other units have not been individually validated." + } +} diff --git a/app/src/main/assets/handtracking/hand_landmarker.task b/app/src/main/assets/handtracking/hand_landmarker.task new file mode 100644 index 0000000000..0d53faf378 Binary files /dev/null and b/app/src/main/assets/handtracking/hand_landmarker.task differ diff --git a/app/src/main/assets/handtracking/pose_landmarker_lite.task b/app/src/main/assets/handtracking/pose_landmarker_lite.task new file mode 100644 index 0000000000..09576a9301 Binary files /dev/null and b/app/src/main/assets/handtracking/pose_landmarker_lite.task differ diff --git a/app/src/main/assets/models/hand_landmarker.provenance.json b/app/src/main/assets/models/hand_landmarker.provenance.json new file mode 100644 index 0000000000..d9dd876645 --- /dev/null +++ b/app/src/main/assets/models/hand_landmarker.provenance.json @@ -0,0 +1,9 @@ +{ + "url": "https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task", + "sha256": "fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1", + "bytes": 7819105, + "mediapipe": "com.google.mediapipe:tasks-vision:1.0.0", + "opencv": "org.opencv:opencv:4.13.0", + "documentation": "https://ai.google.dev/edge/mediapipe/solutions/vision/hand_landmarker", + "runtime": "Two video-mode instances; CPU default; GPU requires separate performance acceptance" +} diff --git a/app/src/main/assets/models/hand_landmarker.task b/app/src/main/assets/models/hand_landmarker.task new file mode 100644 index 0000000000..0d53faf378 Binary files /dev/null and b/app/src/main/assets/models/hand_landmarker.task differ diff --git a/app/src/main/assets/models/hand_landmarker_lite.provenance.json b/app/src/main/assets/models/hand_landmarker_lite.provenance.json new file mode 100644 index 0000000000..29bebf8d73 --- /dev/null +++ b/app/src/main/assets/models/hand_landmarker_lite.provenance.json @@ -0,0 +1,12 @@ +{ + "sha256": "173c0f47ecee7e935bd4a1e93aa580756b4180c1307c07d709313e82c28672c8", + "composition": "Lite palm detector and lite hand landmarks with matching Tasks tensor metadata and associated files from the full bundle", + "palm_source": "https://storage.googleapis.com/mediapipe-assets/palm_detection_lite.tflite", + "palm_source_sha256": "e9a4aaddf90dda56a87235303cf00e4c2d3fb28725f68fd88772997dac905c18", + "landmark_source": "https://storage.googleapis.com/mediapipe-assets/hand_landmark_lite.tflite", + "landmark_source_sha256": "d7fde8ac11f8ce03f8663775bfc323f4fc9f2a38062b4f4efa142874ef5b2a48", + "metadata_source": "hand_landmarker.task", + "metadata_source_sha256": "fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1", + "builder": "tools/build_hand_lite.py; mediapipe==0.10.21; deterministic ZIP_STORED bundle and embedded associated-file archives", + "runtime": "com.google.mediapipe:tasks-vision:1.0.0; CPU by default; experimental stereo hand and wrist tracking" +} diff --git a/app/src/main/assets/models/hand_landmarker_lite.task b/app/src/main/assets/models/hand_landmarker_lite.task new file mode 100644 index 0000000000..4c0ab68b42 Binary files /dev/null and b/app/src/main/assets/models/hand_landmarker_lite.task differ diff --git a/app/src/main/assets/steam-startup/droiddeck-startup-60.webm b/app/src/main/assets/steam-startup/droiddeck-startup-60.webm new file mode 100644 index 0000000000..3ecf0b37c3 Binary files /dev/null and b/app/src/main/assets/steam-startup/droiddeck-startup-60.webm differ diff --git a/app/src/main/cpp/CMakeLists.txt b/app/src/main/cpp/CMakeLists.txt index fdb58ac308..01a0a97a2b 100644 --- a/app/src/main/cpp/CMakeLists.txt +++ b/app/src/main/cpp/CMakeLists.txt @@ -30,6 +30,7 @@ string(SUBSTRING "${WINFG_CHAIN_HASH_FULL}" 0 12 WINFG_CHAIN_HASH) message(STATUS "win-fg chain: ${WINFG_UPSTREAM} (src ${WINFG_CHAIN_HASH})") add_subdirectory(waylandcomp) +add_subdirectory(questxr) add_library(sdnative SHARED sdnative/sdnative.c) target_link_libraries(sdnative log) @@ -37,3 +38,24 @@ add_library(deviceinfo SHARED deviceinfo/vkinfo.c) target_link_libraries(deviceinfo dl) add_library(termux SHARED termux/termux.c) + +# The optional proprietary SDK is supplied locally; its headers/libraries are not vendored. +if(DROIDDECK_VITURE_SDK_DIR) + add_library(droiddeck_viture SHARED viture/sdk_bridge.cpp) + target_compile_features(droiddeck_viture PRIVATE cxx_std_17) + target_include_directories(droiddeck_viture PRIVATE "${DROIDDECK_VITURE_SDK_DIR}/include") + target_link_directories(droiddeck_viture PRIVATE "${DROIDDECK_VITURE_SDK_DIR}/android/${ANDROID_ABI}") + target_link_libraries(droiddeck_viture PRIVATE glasses log) +endif() + +if(DROIDDECK_UVC_DIR) + add_library(rgb_usb SHARED IMPORTED) + set_target_properties(rgb_usb PROPERTIES IMPORTED_LOCATION "${DROIDDECK_UVC_DIR}/${ANDROID_ABI}/libusb.so") + add_library(rgb_uvc STATIC IMPORTED) + set_target_properties(rgb_uvc PROPERTIES IMPORTED_LOCATION "${DROIDDECK_UVC_DIR}/${ANDROID_ABI}/libuvc.a") + add_library(droiddeck_uvc SHARED viture/uvc_bridge.cpp) + target_compile_features(droiddeck_uvc PRIVATE cxx_std_17) + target_include_directories(droiddeck_uvc PRIVATE "${DROIDDECK_UVC_DIR}/include") + target_link_libraries(droiddeck_uvc PRIVATE rgb_uvc rgb_usb log) + target_link_options(droiddeck_uvc PRIVATE -Wl,-z,max-page-size=16384) +endif() diff --git a/app/src/main/cpp/fakeinput_steam.cpp b/app/src/main/cpp/fakeinput_steam.cpp index d1864a277e..486b72076e 100644 --- a/app/src/main/cpp/fakeinput_steam.cpp +++ b/app/src/main/cpp/fakeinput_steam.cpp @@ -75,7 +75,16 @@ static constexpr uint8_t GAMEPAD_AXIS_COUNT = 8; static constexpr uint8_t GAMEPAD_BUTTON_COUNT = 11; static constexpr uint32_t FAKE_INPUT_RING_MAGIC = 0x46494252; static constexpr uint32_t FAKE_INPUT_RING_VERSION = 2; -static constexpr uint32_t FAKE_INPUT_EVENT_SIZE = sizeof(struct input_event); +// Rings hold the 64-bit input_event layout that the arm64 writers use; 32-bit guests convert on read. +struct RingEvent { + int64_t sec; + int64_t usec; + uint16_t type; + uint16_t code; + int32_t value; +}; +static_assert(sizeof(RingEvent) == 24, "ring events must stay ABI-stable"); +static constexpr uint32_t FAKE_INPUT_EVENT_SIZE = sizeof(RingEvent); static constexpr uint32_t FAKE_INPUT_RING_CAPACITY = 4096; static constexpr unsigned int FAKE_INPUT_MAJOR = 13; static constexpr unsigned int FAKE_INPUT_EVENT_MINOR_BASE = 64; @@ -371,6 +380,17 @@ send_vibration(int strong, int weak, uint16_t duration_ms, uint16_t slot) { syscall(SYS_close, sock); } +// Must match RumbleComponent.HOLD_MS: play until the slot's next effect or stop. +static constexpr uint16_t RUMBLE_HOLD_MS = 0xffff; + +__attribute__((visibility("hidden"))) static void send_ff_effect(const struct ff_effect &effect, uint16_t slot) { + uint16_t duration = effect.replay.length ? effect.replay.length : RUMBLE_HOLD_MS; + if (effect.type == FF_RUMBLE) + send_vibration(effect.u.rumble.strong_magnitude, effect.u.rumble.weak_magnitude, duration, slot); + else if (effect.type == FF_PERIODIC) + send_vibration(effect.u.periodic.magnitude, effect.u.periodic.magnitude, duration, slot); +} + __attribute__((visibility("hidden"))) static void check_ff_event(const struct input_event *ev, uint16_t slot) { if (ev->type != EV_FF) @@ -381,15 +401,7 @@ check_ff_event(const struct input_event *ev, uint16_t slot) { auto it = ff_effects().find(id); if (it == ff_effects().end()) return; - - uint16_t duration = it->second.replay.length; - if (it->second.type == FF_RUMBLE) { - send_vibration(it->second.u.rumble.strong_magnitude, - it->second.u.rumble.weak_magnitude, duration, slot); - } else if (it->second.type == FF_PERIODIC) { - send_vibration(it->second.u.periodic.magnitude, - it->second.u.periodic.magnitude, duration, slot); - } + send_ff_effect(it->second, slot); } else { send_vibration(0, 0, 0, slot); } @@ -925,14 +937,13 @@ __attribute__((visibility("hidden"))) static void flush_uinput(UinputWriter &w) return; } FakeInputRingHeader *ring = w.ring; - auto *events = reinterpret_cast(reinterpret_cast(ring) + - FAKE_INPUT_RING_HEADER_SIZE); + auto *events = reinterpret_cast(reinterpret_cast(ring) + + FAKE_INPUT_RING_HEADER_SIZE); uint64_t write_seq = __atomic_load_n(&ring->write_seq, __ATOMIC_RELAXED); struct timeval now = {}; gettimeofday(&now, nullptr); - for (struct input_event ev : w.pending) { - ev.time = now; - events[write_seq % FAKE_INPUT_RING_CAPACITY] = ev; + for (const struct input_event &ev : w.pending) { + events[write_seq % FAKE_INPUT_RING_CAPACITY] = {now.tv_sec, now.tv_usec, ev.type, ev.code, ev.value}; write_seq++; if (ev.type == EV_KEY) { for (size_t i = 0; i < kSnapshotButtonCount; i++) @@ -3469,16 +3480,7 @@ EXPORT int ioctl(int fd, ioctl_request_t op, ...) { if (effect->id == -1) effect->id = next_ff_id++; ff_effects()[effect->id] = *effect; - - uint16_t duration = effect->replay.length; - uint16_t slot = static_cast(event_number); - if (effect->type == FF_RUMBLE) { - send_vibration(effect->u.rumble.strong_magnitude, - effect->u.rumble.weak_magnitude, duration, slot); - } else if (effect->type == FF_PERIODIC) { - send_vibration(effect->u.periodic.magnitude, effect->u.periodic.magnitude, - duration, slot); - } + send_ff_effect(*effect, static_cast(event_number)); return 0; } else if (type == 0x45 && number == 0x81) { int id = (intptr_t)argp; @@ -3517,6 +3519,12 @@ EXPORT int ioctl(int fd, ioctl_request_t op, ...) { } else if (type == 0x45 && number == 0x90) { Logger::log("Hooking ioctl EVIOCGRAB for event %s\n", event); return 0; + } else if (type == 0x6A && !strncmp(event, "event", 5)) { + // Older SDL2 builds treat any JSIOCGNAME answer as a joydev node and skip EVIOCGID, then drop the pad as 0000:0000. + Logger::log("Rejecting joydev ioctl %d for event %s\n", number, event); + guard.unlock(); + errno = EINVAL; + return -1; } else if (type == 0x6A && number == 0x1) { Logger::log("Hooking ioctl JSIOCGVERSION for event %s\n", event); int version = JS_VERSION; @@ -3579,7 +3587,7 @@ EXPORT ssize_t read(int fd, void *buf, size_t count) { } auto handle = controller->second; FakeController &fake = *handle; - if (count < FAKE_INPUT_EVENT_SIZE) { + if (count < sizeof(struct input_event)) { errno = EINVAL; return -1; } @@ -3597,7 +3605,7 @@ EXPORT ssize_t read(int fd, void *buf, size_t count) { return -1; } for (int attempt = 0; attempt < 8; ++attempt) { - size_t requested = count / FAKE_INPUT_EVENT_SIZE; + size_t requested = count / sizeof(struct input_event); if (fake.keyframe_remaining == 0) { SnapshotState snap; if (!read_snapshot(fake.ring, snap)) break; @@ -3616,17 +3624,22 @@ EXPORT ssize_t read(int fd, void *buf, size_t count) { FAKE_INPUT_RING_HEADER_SIZE; for (size_t i = 0; i < events; ++i) { size_t index = (fake.read_seq + i) % FAKE_INPUT_RING_CAPACITY; - struct input_event ev; - memcpy(&ev, ring_events + index * FAKE_INPUT_EVENT_SIZE, FAKE_INPUT_EVENT_SIZE); + RingEvent stored; + memcpy(&stored, ring_events + index * FAKE_INPUT_EVENT_SIZE, FAKE_INPUT_EVENT_SIZE); + struct input_event ev = {}; + ev.time.tv_sec = stored.sec; + ev.time.tv_usec = stored.usec; + ev.type = stored.type; + ev.code = stored.code; + ev.value = stored.value; if (ev.type == EV_ABS) ev.code = presented_abs_code(fake, ev.code); - memcpy(static_cast(buf) + i * FAKE_INPUT_EVENT_SIZE, &ev, - FAKE_INPUT_EVENT_SIZE); + memcpy(static_cast(buf) + i * sizeof(ev), &ev, sizeof(ev)); } __atomic_thread_fence(__ATOMIC_ACQUIRE); if (snap.sequence != __atomic_load_n(&fake.ring->snapshot_seq, __ATOMIC_RELAXED)) continue; fake.read_seq += events; - return static_cast(events * FAKE_INPUT_EVENT_SIZE); + return static_cast(events * sizeof(struct input_event)); } } @@ -3641,11 +3654,10 @@ EXPORT ssize_t read(int fd, void *buf, size_t count) { ev.code = kNeutralEvents[index].code; ev.value = keyframe_value(fake, ev.type, ev.code); if (ev.type == EV_ABS) ev.code = presented_abs_code(fake, ev.code); - memcpy(static_cast(buf) + i * FAKE_INPUT_EVENT_SIZE, - &ev, FAKE_INPUT_EVENT_SIZE); + memcpy(static_cast(buf) + i * sizeof(ev), &ev, sizeof(ev)); --fake.keyframe_remaining; } - return static_cast(events * FAKE_INPUT_EVENT_SIZE); + return static_cast(events * sizeof(struct input_event)); } if (nonblock) { errno = EAGAIN; diff --git a/app/src/main/cpp/questxr/CMakeLists.txt b/app/src/main/cpp/questxr/CMakeLists.txt new file mode 100644 index 0000000000..c23558bb0b --- /dev/null +++ b/app/src/main/cpp/questxr/CMakeLists.txt @@ -0,0 +1,13 @@ +cmake_minimum_required(VERSION 3.22.1) +project(droiddeckxr C CXX) +find_package(OpenXR REQUIRED CONFIG) +add_library(droiddeckxr_glue STATIC ${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c) +target_include_directories(droiddeckxr_glue PUBLIC ${ANDROID_NDK}/sources/android/native_app_glue) +add_library(droiddeckxr SHARED quest_xr.cpp) +target_compile_features(droiddeckxr PRIVATE cxx_std_17) +target_compile_definitions(droiddeckxr PRIVATE XR_USE_PLATFORM_ANDROID XR_USE_GRAPHICS_API_OPENGL_ES XR_USE_TIMESPEC) +target_compile_options(droiddeckxr PRIVATE -Wall -Wextra -Wno-missing-field-initializers -Werror=return-type) +target_link_options(droiddeckxr PRIVATE -Wl,-z,max-page-size=16384 -uANativeActivity_onCreate) +target_link_libraries(droiddeckxr PRIVATE droiddeckxr_glue OpenXR::openxr_loader EGL GLESv3 android log) + +target_include_directories(droiddeckxr PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../tools/vr/src) diff --git a/app/src/main/cpp/questxr/gpu_frames.h b/app/src/main/cpp/questxr/gpu_frames.h new file mode 100644 index 0000000000..dc69dbbfb6 --- /dev/null +++ b/app/src/main/cpp/questxr/gpu_frames.h @@ -0,0 +1,201 @@ +#pragma once +#include +#include +#include +#include +#include "xr_gpu_channel.h" + +class QuestGpuFrames { +public: + bool Start(const std::string &filename, EGLDisplay display) { + const char *extensions = reinterpret_cast(glGetString(GL_EXTENSIONS)); + const char *eglExtensions = eglQueryString(display, EGL_EXTENSIONS); + if (!extensions || !eglExtensions || !strstr(extensions, "GL_EXT_external_buffer") + || !strstr(eglExtensions, "EGL_ANDROID_get_native_client_buffer")) return false; + storage_ = reinterpret_cast(eglGetProcAddress("glBufferStorageExternalEXT")); + client_ = reinterpret_cast(eglGetProcAddress("eglGetNativeClientBufferANDROID")); + if (strstr(extensions, "GL_OES_texture_view")) view_ = reinterpret_cast(eglGetProcAddress("glTextureViewOES")); + else if (strstr(extensions, "GL_EXT_texture_view")) view_ = reinterpret_cast(eglGetProcAddress("glTextureViewEXT")); + if (!storage_ || !client_ || !view_ || filename.size() >= sizeof(sockaddr_un::sun_path)) return false; + const char *source = "#version 310 es\nlayout(local_size_x=8,local_size_y=8)in;" + "layout(std430,binding=0)readonly buffer Source{uint pixels[];};" + "layout(rgba8,binding=0)writeonly uniform highp image2D target;uniform bool bgra;" + "void main(){ivec2 p=ivec2(gl_GlobalInvocationID.xy),size=imageSize(target);" + "if(any(greaterThanEqual(p,size)))return;vec4 value=unpackUnorm4x8(pixels[p.y*size.x+p.x]);" + "imageStore(target,p,bgra?value.bgra:value);}"; + GLuint shader = glCreateShader(GL_COMPUTE_SHADER); glShaderSource(shader, 1, &source, nullptr); glCompileShader(shader); + program_ = glCreateProgram(); glAttachShader(program_, shader); glLinkProgram(program_); glDeleteShader(shader); + GLint linked{}; glGetProgramiv(program_, GL_LINK_STATUS, &linked); + if (!linked) { Stop(); return false; } + lock_ = open((filename + ".lock").c_str(), O_CREAT | O_RDWR | O_CLOEXEC | O_NOFOLLOW, 0600); + struct stat status{}; + if (lock_ < 0 || fstat(lock_, &status) || !S_ISREG(status.st_mode) || status.st_uid != getuid() + || flock(lock_, LOCK_EX | LOCK_NB)) { Stop(); return false; } + if (lstat(filename.c_str(), &status) == 0) { + if (!S_ISSOCK(status.st_mode) || status.st_uid != getuid() || unlink(filename.c_str())) { Stop(); return false; } + } else if (errno != ENOENT) { Stop(); return false; } + listener_ = socket(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC | SOCK_NONBLOCK, 0); + sockaddr_un address{}; address.sun_family = AF_UNIX; strcpy(address.sun_path, filename.c_str()); + if (listener_ < 0 || bind(listener_, reinterpret_cast(&address), sizeof(address))) { Stop(); return false; } + filename_ = filename; + if (chmod(filename.c_str(), 0600) || listen(listener_, 2)) { Stop(); return false; } + return true; + } + + bool Take(DroidDeckXrFrameHeader &header, GLuint &texture) { + if (listener_ < 0) return false; + if (peer_ < 0) { + peer_ = accept4(listener_, nullptr, nullptr, SOCK_CLOEXEC | SOCK_NONBLOCK); + if (peer_ < 0) return false; + if (!xr_frame_peer(peer_)) { Disconnect(); return false; } + configured_ = false; deadline_ = xr_frame_now() + 2000000000LL; + } + pollfd ready{peer_, POLLIN, 0}; + if (poll(&ready, 1, 0) <= 0) { + if (!configured_ && xr_frame_now() > deadline_) Disconnect(); + return false; + } + if (!(ready.revents & POLLIN)) { Disconnect(); return false; } + if (!configured_) { + XrGpuRequest request; + if (!xr_gpu_receive(peer_, &request, sizeof(request)) || request.magic != XR_GPU_MAGIC + || request.version != XR_GPU_VERSION || !xr_gpu_dimensions(request.width, request.height) + || !Allocate(request.width, request.height)) { Disconnect(); return false; } + XrGpuPoolInfo info; info.width = width_; info.height = height_; + for (unsigned index = 0; index < XR_GPU_SLOTS; index++) info.sizes[index] = sizes_[index]; + configured_ = xr_gpu_send(peer_, &info, sizeof(info), fds_.data(), fds_.size()); + for (int &fd : fds_) { if (fd >= 0) close(fd); fd = -1; } + if (!configured_) Disconnect(); + return false; + } + XrGpuFrame frame; + if (!xr_gpu_receive(peer_, &frame, sizeof(frame))) { Disconnect(); return false; } + auto state = xr_gpu_frame_state(frame, width_, height_, lastFrame_, xr_frame_now()); + if (state == XrGpuFrameState::Invalid) { + rejected_++; Disconnect(); return false; + } + lastFrame_ = frame.header.frame_id; + if (state == XrGpuFrameState::Stale) { + // No GPU read was submitted, so the producer can safely reclaim a dropped frame. + dropped_++; + if (!xr_gpu_send(peer_, &frame.header.frame_id, sizeof(frame.header.frame_id))) Disconnect(); + return false; + } + if (!Output()) { Disconnect(); return false; } + glMemoryBarrier(GL_ALL_BARRIER_BITS); + glUseProgram(program_); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, buffers_[frame.slot]); + glUniform1i(glGetUniformLocation(program_, "bgra"), !!(frame.flags & XR_GPU_BGRA)); + glBindImageTexture(0, raw_, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8); + glDispatchCompute((width_ + 7) / 8, (height_ + 7) / 8, 1); + glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT | GL_SHADER_IMAGE_ACCESS_BARRIER_BIT); + // The producer may overwrite this slot only after the native GPU has finished reading it. + glFinish(); + if (glGetError() != GL_NO_ERROR) { rejected_++; Disconnect(); return false; } + if (!xr_gpu_send(peer_, &frame.header.frame_id, sizeof(frame.header.frame_id))) Disconnect(); + received_++; + header = frame.header; + texture = header.color_space == DROIDDECK_XR_COLOR_SRGB_RGBA8 ? srgb_ : raw_; + return true; + } + + uint64_t Received() const { return received_; } + uint64_t Rejected() const { return rejected_; } + uint64_t Dropped() const { return dropped_; } + void Stop() { + Disconnect(); DropPool(); + glDeleteTextures(1, &srgb_); glDeleteTextures(1, &raw_); srgb_ = raw_ = 0; + if (program_) glDeleteProgram(program_); program_ = 0; + if (listener_ >= 0) close(listener_); listener_ = -1; + if (!filename_.empty()) unlink(filename_.c_str()); filename_.clear(); + if (lock_ >= 0) close(lock_); lock_ = -1; + } +private: + int listener_ = -1, peer_ = -1, lock_ = -1; + std::string filename_; + bool configured_ = false; + int64_t deadline_{}; + uint32_t width_{}, height_{}, outputWidth_{}, outputHeight_{}; + uint64_t lastFrame_{}, received_{}, rejected_{}, dropped_{}; + std::array hardware_{}; + std::array buffers_{}; + std::array fds_{{-1, -1, -1}}; + std::array sizes_{}; + GLuint raw_{}, srgb_{}, program_{}; + PFNGLBUFFERSTORAGEEXTERNALEXTPROC storage_{}; + PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC client_{}; + PFNGLTEXTUREVIEWOESPROC view_{}; + + void Disconnect() { if (peer_ >= 0) close(peer_); peer_ = -1; configured_ = false; lastFrame_ = 0; } + void DropPool() { + if (buffers_[0]) glFinish(); + glDeleteBuffers(buffers_.size(), buffers_.data()); buffers_.fill(0); + for (auto *&buffer : hardware_) { if (buffer) AHardwareBuffer_release(buffer); buffer = nullptr; } + for (int &fd : fds_) { if (fd >= 0) close(fd); fd = -1; } + } + static int AllocationFd(AHardwareBuffer *buffer, uint64_t bytes, uint64_t &allocation) { + int pair[2]; + if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, pair)) return -1; + if (AHardwareBuffer_sendHandleToUnixSocket(buffer, pair[0])) { close(pair[0]); close(pair[1]); return -1; } + close(pair[0]); + int selected = -1; unsigned candidates = 0; + for (;;) { + unsigned char data[1024]; iovec bytesReceived{data, sizeof(data)}; + alignas(cmsghdr) unsigned char control[CMSG_SPACE(32 * sizeof(int))]{}; + msghdr message{}; message.msg_iov = &bytesReceived; message.msg_iovlen = 1; + message.msg_control = control; message.msg_controllen = sizeof(control); + ssize_t result = recvmsg(pair[1], &message, MSG_CMSG_CLOEXEC); + if (result < 0 && errno == EINTR) continue; + if (result <= 0) break; + for (auto *item = CMSG_FIRSTHDR(&message); item; item = CMSG_NXTHDR(&message, item)) { + if (item->cmsg_level != SOL_SOCKET || item->cmsg_type != SCM_RIGHTS) continue; + auto *fds = reinterpret_cast(CMSG_DATA(item)); + for (unsigned index = 0; index < (item->cmsg_len - CMSG_LEN(0)) / sizeof(int); index++) { + struct stat status{}; + if (!fstat(fds[index], &status) && status.st_size >= static_cast(bytes) + && status.st_size <= static_cast(bytes + 65536)) { + candidates++; if (selected >= 0) close(selected); + selected = fds[index]; allocation = status.st_size; + } else close(fds[index]); + } + } + if (message.msg_flags & (MSG_TRUNC | MSG_CTRUNC)) { candidates = 0; break; } + } + close(pair[1]); + if (candidates != 1) { if (selected >= 0) close(selected); return -1; } + return selected; + } + bool Allocate(uint32_t width, uint32_t height) { + DropPool(); width_ = width; height_ = height; + const uint64_t bytes = uint64_t(width) * height * 4; + GLint64 limit{}; glGetInteger64v(GL_MAX_SHADER_STORAGE_BLOCK_SIZE, &limit); + if (bytes > static_cast(limit)) return false; + AHardwareBuffer_Desc description{}; description.width = bytes; description.height = description.layers = 1; + description.format = AHARDWAREBUFFER_FORMAT_BLOB; + description.usage = AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER; + glGenBuffers(buffers_.size(), buffers_.data()); + for (unsigned index = 0; index < XR_GPU_SLOTS; index++) { + if (AHardwareBuffer_allocate(&description, &hardware_[index])) { DropPool(); return false; } + fds_[index] = AllocationFd(hardware_[index], bytes, sizes_[index]); + if (fds_[index] < 0) { DropPool(); return false; } + glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffers_[index]); + storage_(GL_SHADER_STORAGE_BUFFER, 0, bytes, client_(hardware_[index]), 0); + if (glGetError() != GL_NO_ERROR) { DropPool(); return false; } + } + glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0); + return true; + } + bool Output() { + if (raw_ && outputWidth_ == width_ && outputHeight_ == height_) return true; + glDeleteTextures(1, &srgb_); glDeleteTextures(1, &raw_); srgb_ = raw_ = 0; + glGenTextures(1, &raw_); glBindTexture(GL_TEXTURE_2D, raw_); + glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, width_, height_); + glGenTextures(1, &srgb_); view_(srgb_, GL_TEXTURE_2D, raw_, GL_SRGB8_ALPHA8, 0, 1, 0, 1); + for (GLuint texture : {raw_, srgb_}) { + glBindTexture(GL_TEXTURE_2D, texture); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + } + outputWidth_ = width_; outputHeight_ = height_; + return glGetError() == GL_NO_ERROR; + } +}; diff --git a/app/src/main/cpp/questxr/quest_xr.cpp b/app/src/main/cpp/questxr/quest_xr.cpp new file mode 100644 index 0000000000..09423c7d1a --- /dev/null +++ b/app/src/main/cpp/questxr/quest_xr.cpp @@ -0,0 +1,777 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "xr_tracking.h" +#include "xr_frame_channel.h" +#include "xr_frame_math.h" +#include "gpu_frames.h" + +static void check(XrResult result, const char *operation) { + if (XR_FAILED(result)) throw std::runtime_error(std::string(operation) + ": " + std::to_string(result)); +} + +struct Eye { + XrSwapchain swapchain = XR_NULL_HANDLE; + int width = 0, height = 0; + std::vector images; +}; + +class QuestXR { +public: + explicit QuestXR(android_app *app) : app_(app) {} + ~QuestXR() { cleanup(); } + + void run() { + initialize(); + while (!app_->destroyRequested && !exit_) { + android_poll_source *source = nullptr; + int events = 0; + int pollTimeout = running_ ? 0 : 100; + for (int eventCount = 0; eventCount < 32; eventCount++) { + if (ALooper_pollOnce(pollTimeout, nullptr, &events, reinterpret_cast(&source)) < 0) break; + if (source) source->process(app_, source); + if (app_->destroyRequested) break; + pollTimeout = 0; + } + receiveFrame(); + pollEvents(); + if (running_ && !app_->destroyRequested) frame(); + } + if (exit_ && !app_->destroyRequested) ANativeActivity_finish(app_->activity); + } + + void health(const char *error = "") { + int steamvrState = -1; + if (statusCallback_) { + steamvrState = env_->CallIntMethod(app_->activity->clazz, statusCallback_); + if (env_->ExceptionCheck()) { env_->ExceptionClear(); steamvrState = -1; } + } + std::string path = std::string(app_->activity->externalDataPath) + "/xr-health.json"; + std::string temp = path + ".tmp"; + FILE *file = std::fopen(temp.c_str(), "w"); + if (!file) return; + std::fprintf(file, + "{\"frames\":%llu,\"rendered\":%llu,\"sessionState\":%d,\"headFlags\":%llu," + "\"headPosition\":[%.6f,%.6f,%.6f],\"controllersActive\":[%s,%s]," + "\"periodNs\":%lld,\"surfaceSwapchain\":%s,\"source\":\"%s\",\"guestFrames\":%lld,\"steamvrState\":%d," + "\"receivedFrames\":%llu,\"rejectedFrames\":%llu,\"uploadedFrames\":%llu,\"sourceFrameId\":%llu," + "\"gpuReceivedFrames\":%llu,\"gpuDroppedFrames\":%llu,\"gpuVerifiedFrameId\":%llu,\"gpuChecksum\":%u,\"error\":\"%s\"}\n", + (unsigned long long)frames_, (unsigned long long)rendered_, state_, + (unsigned long long)head_.locationFlags, + head_.pose.position.x, head_.pose.position.y, head_.pose.position.z, + handActive_[0] ? "true" : "false", handActive_[1] ? "true" : "false", + (long long)period_, "false", "frames", + 0LL, steamvrState, (unsigned long long)(receiver_.Received() + gpuFrames_.Received()), + (unsigned long long)(receiver_.Rejected() + gpuFrames_.Rejected()), + (unsigned long long)uploadedFrames_, (unsigned long long)sourceHeader_.frame_id, + (unsigned long long)gpuFrames_.Received(), (unsigned long long)gpuFrames_.Dropped(), + (unsigned long long)verifiedFrame_, gpuChecksum_, error); + std::fclose(file); + std::rename(temp.c_str(), path.c_str()); + } + +private: + android_app *app_; + JNIEnv *env_ = nullptr; + XrInstance instance_ = XR_NULL_HANDLE; + XrSession session_ = XR_NULL_HANDLE; + XrSystemId system_ = XR_NULL_SYSTEM_ID; + XrSpace world_ = XR_NULL_HANDLE, view_ = XR_NULL_HANDLE; + XrActionSet actions_ = XR_NULL_HANDLE; + XrAction grip_ = XR_NULL_HANDLE, trigger_ = XR_NULL_HANDLE, vibration_ = XR_NULL_HANDLE; + XrAction squeeze_ = XR_NULL_HANDLE, stick_ = XR_NULL_HANDLE, stickClick_ = XR_NULL_HANDLE; + XrAction primary_ = XR_NULL_HANDLE, secondary_ = XR_NULL_HANDLE, menu_ = XR_NULL_HANDLE; + XrAction triggerTouch_ = XR_NULL_HANDLE, stickTouch_ = XR_NULL_HANDLE, primaryTouch_ = XR_NULL_HANDLE; + XrAction secondaryTouch_ = XR_NULL_HANDLE, thumbrestTouch_ = XR_NULL_HANDLE; + DroidDeckXrHand inputs_[2]{}; + PFN_xrConvertTimeToTimespecTimeKHR convertTime_ = nullptr; + bool timespecSupported_ = false; + PFN_xrPerfSettingsSetPerformanceLevelEXT setPerformance_ = nullptr; + bool performanceSupported_ = false; + XrPath hands_[2]{}; + XrSpace handSpaces_[2]{}; + XrSpaceLocation head_{XR_TYPE_SPACE_LOCATION}; + XrSpaceLocation handLocations_[2]{{XR_TYPE_SPACE_LOCATION}, {XR_TYPE_SPACE_LOCATION}}; + bool handActive_[2]{}; + bool running_ = false, exit_ = false, quitRequested_ = false; + bool guestAttached_ = false, verifyPixels_ = false; + XrFrameReceiver receiver_; + QuestGpuFrames gpuFrames_; + DroidDeckXrFrameHeader sourceHeader_{}; + uint64_t uploadedFrames_ = 0, verifiedFrame_ = 0; + uint32_t gpuChecksum_ = 0; + GLuint sourceTexture_ = 0, sourceProgram_ = 0; + GLuint cpuTexture_ = 0; + jmethodID frameCallback_ = nullptr; + jmethodID activeCallback_ = nullptr; + jmethodID statusCallback_ = nullptr; + DroidDeckXrTracking *tracking_ = nullptr; + DroidDeckXrHaptics *haptics_ = nullptr; + uint64_t lastPulse_[2]{}; + XrSessionState state_ = XR_SESSION_STATE_UNKNOWN; + uint64_t frames_ = 0, rendered_ = 0; + XrDuration period_ = 0; + EGLDisplay display_ = EGL_NO_DISPLAY; + EGLContext context_ = EGL_NO_CONTEXT; + EGLSurface surface_ = EGL_NO_SURFACE; + std::array eyes_; + GLuint framebuffer_ = 0, vertexArray_ = 0; + GLint sourceEncoding_ = 0, eyeEncoding_ = 0; + + std::string captureRequest() { + if (frames_ % 9) return {}; + std::string file = std::string(app_->activity->externalDataPath) + "/xr-capture.request"; + FILE *request = std::fopen(file.c_str(), "r"); + if (!request) return {}; + char token[34]{}; + size_t size = std::fread(token, 1, sizeof(token) - 1, request); + std::fclose(request); + unlink(file.c_str()); + if (size != 32 || std::strspn(token, "0123456789abcdef") != 32) return {}; + unlink((std::string(app_->activity->externalDataPath) + "/xr-capture.json").c_str()); + return token; + } + + bool captureTexture(GLuint texture, int width, int height, const char *name) { + glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0); + GLint encoding = 0; + glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, + GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, &encoding); + if (!std::strcmp(name, "source")) sourceEncoding_ = encoding; + else eyeEncoding_ = encoding; + std::vector pixels((size_t)width * height * 4); + glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data()); + bool ok = glGetError() == GL_NO_ERROR; + glBindFramebuffer(GL_FRAMEBUFFER, 0); + if (!ok) return false; + std::string file = std::string(app_->activity->externalDataPath) + + "/xr-capture-" + name + ".ppm"; + std::string temporary = file + ".tmp"; + FILE *output = std::fopen(temporary.c_str(), "wb"); + if (!output) return false; + ok = std::fprintf(output, "P6\n%d %d\n255\n", width, height) > 0; + std::vector row((size_t)width * 3); + for (int y = height - 1; y >= 0 && ok; y--) { + for (int x = 0; x < width; x++) + std::memcpy(row.data() + x * 3, pixels.data() + ((size_t)y * width + x) * 4, 3); + ok = std::fwrite(row.data(), 1, row.size(), output) == row.size(); + } + if (std::fclose(output) != 0) ok = false; + if (!ok) { unlink(temporary.c_str()); return false; } + return std::rename(temporary.c_str(), file.c_str()) == 0; + } + + void captureResult(const std::string &token, bool ok, bool valid, + const XrCompositionLayerProjectionView (&views)[2], XrTime displayTime) { + std::string file = std::string(app_->activity->externalDataPath) + "/xr-capture.json"; + std::string temporary = file + ".tmp"; + FILE *output = std::fopen(temporary.c_str(), "w"); + if (!output) return; + std::fprintf(output, "{\"id\":\"%s\",\"ok\":%s,\"validLayer\":%s,\"frame\":%llu," + "\"sourceFrameId\":%llu,\"displayTime\":%lld,\"sessionState\":%d,\"eyes\":[", + token.c_str(), ok ? "true" : "false", valid ? "true" : "false", + (unsigned long long)frames_, (unsigned long long)sourceHeader_.frame_id, (long long)displayTime, state_); + for (int eye = 0; eye < 2; eye++) { + const auto &pose = views[eye].pose; + const auto &fov = views[eye].fov; + std::fprintf(output, "%s{\"width\":%d,\"height\":%d,\"position\":[%g,%g,%g]," + "\"orientation\":[%g,%g,%g,%g],\"fov\":[%g,%g,%g,%g]}", + eye ? "," : "", eyes_[eye].width, eyes_[eye].height, + pose.position.x, pose.position.y, pose.position.z, + pose.orientation.x, pose.orientation.y, pose.orientation.z, pose.orientation.w, + fov.angleLeft, fov.angleRight, fov.angleUp, fov.angleDown); + } + const char *extensions = reinterpret_cast(glGetString(GL_EXTENSIONS)); + const bool srgbControl = extensions && std::strstr(extensions, "GL_EXT_sRGB_write_control"); + std::fprintf(output, "],\"sourceImage\":true,\"sourceColorSpace\":\"%s\",\"sourceEncoding\":%d,\"eyeEncoding\":%d," + "\"srgbWriteControl\":%s,\"srgbWriteEnabled\":%s}\n", + sourceHeader_.color_space == DROIDDECK_XR_COLOR_SRGB_RGBA8 ? "srgb" : "linear", sourceEncoding_, eyeEncoding_, + srgbControl ? "true" : "false", srgbControl && glIsEnabled(0x8DB9) ? "true" : "false"); + if (std::fclose(output) == 0) std::rename(temporary.c_str(), file.c_str()); + } + + XrPath path(const char *text) { + XrPath result{}; + check(xrStringToPath(instance_, text, &result), "xrStringToPath"); + return result; + } + + void initialize() { + app_->userData = this; + app_->onInputEvent = [](android_app *app, AInputEvent *event) -> int32_t { + if (AInputEvent_getType(event) != AINPUT_EVENT_TYPE_KEY || AKeyEvent_getKeyCode(event) != AKEYCODE_BACK + || AKeyEvent_getAction(event) != AKEY_EVENT_ACTION_UP) return 0; + auto *runtime = static_cast(app->userData); + if (runtime->running_) { + XrResult result = xrRequestExitSession(runtime->session_); + if (XR_SUCCEEDED(result)) runtime->quitRequested_ = true; + else __android_log_print(ANDROID_LOG_ERROR, "DroidDeckXR", "exit request failed: %d", result); + } else ANativeActivity_finish(app->activity); + return 1; + }; + app_->activity->vm->AttachCurrentThread(&env_, nullptr); + jclass activityClass = env_->GetObjectClass(app_->activity->clazz); + jmethodID getIntent = env_->GetMethodID(activityClass, "getIntent", "()Landroid/content/Intent;"); + jobject intent = env_->CallObjectMethod(app_->activity->clazz, getIntent); + jclass intentClass = env_->GetObjectClass(intent); + jmethodID getBoolean = env_->GetMethodID(intentClass, "getBooleanExtra", "(Ljava/lang/String;Z)Z"); + jstring extra = env_->NewStringUTF("frame_verify"); + verifyPixels_ = env_->CallBooleanMethod(intent, getBoolean, extra, JNI_FALSE); + env_->DeleteLocalRef(extra); + activeCallback_ = env_->GetMethodID(activityClass, "onXrActive", "(Z)V"); + frameCallback_ = env_->GetMethodID(activityClass, "onXrFrame", "(J)V"); + statusCallback_ = env_->GetMethodID(activityClass, "onXrStatus", "()I"); + if (env_->ExceptionCheck()) { env_->ExceptionClear(); throw std::runtime_error("XR activity bridge methods unavailable"); } + env_->DeleteLocalRef(intentClass); env_->DeleteLocalRef(intent); env_->DeleteLocalRef(activityClass); + PFN_xrInitializeLoaderKHR initializeLoader = nullptr; + check(xrGetInstanceProcAddr(XR_NULL_HANDLE, "xrInitializeLoaderKHR", + reinterpret_cast(&initializeLoader)), "loader init entrypoint"); + XrLoaderInitInfoAndroidKHR loader{XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR}; + loader.applicationVM = app_->activity->vm; + loader.applicationContext = app_->activity->clazz; + check(initializeLoader(reinterpret_cast(&loader)), "xrInitializeLoaderKHR"); + uint32_t count = 0; + check(xrEnumerateInstanceExtensionProperties(nullptr, 0, &count, nullptr), "extensions count"); + std::vector extensions(count, {XR_TYPE_EXTENSION_PROPERTIES}); + check(xrEnumerateInstanceExtensionProperties(nullptr, count, &count, extensions.data()), "extensions"); + for (const auto &extension : extensions) { + if (!std::strcmp(extension.extensionName, XR_KHR_CONVERT_TIMESPEC_TIME_EXTENSION_NAME)) + timespecSupported_ = true; + if (!std::strcmp(extension.extensionName, XR_EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME)) + performanceSupported_ = true; + } + std::vector enabled{XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME, XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME}; + if (timespecSupported_) enabled.push_back(XR_KHR_CONVERT_TIMESPEC_TIME_EXTENSION_NAME); + if (performanceSupported_) enabled.push_back(XR_EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME); + XrInstanceCreateInfoAndroidKHR androidInfo{XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR}; + androidInfo.applicationVM = app_->activity->vm; + androidInfo.applicationActivity = app_->activity->clazz; + XrInstanceCreateInfo create{XR_TYPE_INSTANCE_CREATE_INFO}; + create.next = &androidInfo; + std::strcpy(create.applicationInfo.applicationName, "DroidDeck XR"); + create.applicationInfo.applicationVersion = 1; + create.applicationInfo.apiVersion = XR_MAKE_VERSION(1, 0, 0); + create.enabledExtensionCount = enabled.size(); + create.enabledExtensionNames = enabled.data(); + check(xrCreateInstance(&create, &instance_), "xrCreateInstance"); + if (performanceSupported_) { + XrResult result = xrGetInstanceProcAddr(instance_, "xrPerfSettingsSetPerformanceLevelEXT", + reinterpret_cast(&setPerformance_)); + if (XR_FAILED(result)) setPerformance_ = nullptr; + } + if (timespecSupported_) check(xrGetInstanceProcAddr(instance_, "xrConvertTimeToTimespecTimeKHR", + reinterpret_cast(&convertTime_)), "time conversion entrypoint"); + XrSystemGetInfo systemInfo{XR_TYPE_SYSTEM_GET_INFO}; + systemInfo.formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY; + check(xrGetSystem(instance_, &systemInfo, &system_), "xrGetSystem"); + PFN_xrGetOpenGLESGraphicsRequirementsKHR requirementsFunction = nullptr; + check(xrGetInstanceProcAddr(instance_, "xrGetOpenGLESGraphicsRequirementsKHR", + reinterpret_cast(&requirementsFunction)), "GLES requirements entrypoint"); + XrGraphicsRequirementsOpenGLESKHR requirements{XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR}; + check(requirementsFunction(instance_, system_, &requirements), "GLES requirements"); + if (requirements.minApiVersionSupported > XR_MAKE_VERSION(3, 0, 0) + || requirements.maxApiVersionSupported < XR_MAKE_VERSION(3, 0, 0)) + throw std::runtime_error("Runtime does not support GLES 3.0"); + display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY); + if (!eglInitialize(display_, nullptr, nullptr)) throw std::runtime_error("eglInitialize failed"); + const EGLint attributes[] = {EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT, EGL_SURFACE_TYPE, EGL_PBUFFER_BIT | EGL_WINDOW_BIT, + EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8, EGL_DEPTH_SIZE, 24, EGL_NONE}; + EGLConfig config{}; + EGLint found = 0; + if (!eglChooseConfig(display_, attributes, &config, 1, &found) || found != 1) + throw std::runtime_error("EGL config unavailable"); + const EGLint contextAttributes[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE}; + context_ = eglCreateContext(display_, config, EGL_NO_CONTEXT, contextAttributes); + const EGLint surfaceAttributes[] = {EGL_WIDTH, 16, EGL_HEIGHT, 16, EGL_NONE}; + surface_ = eglCreatePbufferSurface(display_, config, surfaceAttributes); + if (!eglMakeCurrent(display_, surface_, surface_, context_)) throw std::runtime_error("eglMakeCurrent failed"); + XrGraphicsBindingOpenGLESAndroidKHR binding{XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR}; + binding.display = display_; binding.config = config; binding.context = context_; + XrSessionCreateInfo sessionInfo{XR_TYPE_SESSION_CREATE_INFO}; + sessionInfo.next = &binding; sessionInfo.systemId = system_; + check(xrCreateSession(instance_, &sessionInfo, &session_), "xrCreateSession"); + XrReferenceSpaceCreateInfo reference{XR_TYPE_REFERENCE_SPACE_CREATE_INFO}; + reference.poseInReferenceSpace.orientation.w = 1; + reference.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_STAGE; + XrResult referenceResult = xrCreateReferenceSpace(session_, &reference, &world_); + if (referenceResult == XR_ERROR_REFERENCE_SPACE_UNSUPPORTED) { + reference.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_LOCAL; + reference.poseInReferenceSpace.position.y = -1.6f; + check(xrCreateReferenceSpace(session_, &reference, &world_), "local standing space"); + } else check(referenceResult, "stage space"); + reference.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_VIEW; + reference.poseInReferenceSpace.position.y = 0; + check(xrCreateReferenceSpace(session_, &reference, &view_), "view space"); + initializeActions(); + initializeImages(); + initializeGraphics(); + initializeTracking(); + { + std::string filename = std::string(app_->activity->internalDataPath) + "/.wayland-rt/" DROIDDECK_XR_FRAME_SOCKET; + if (!receiver_.Start(filename)) throw std::runtime_error("XR frame receiver unavailable"); + bool gpu = !verifyPixels_ && gpuFrames_.Start(std::string(app_->activity->internalDataPath) + "/.wayland-rt/" DROIDDECK_XR_GPU_SOCKET, display_); + __android_log_print(ANDROID_LOG_INFO, "DroidDeckXR", "GPU frame channel available=%d", gpu); + } + health(); + } + + void initializeActions() { + hands_[0] = path("/user/hand/left"); hands_[1] = path("/user/hand/right"); + XrActionSetCreateInfo setInfo{XR_TYPE_ACTION_SET_CREATE_INFO}; + std::strcpy(setInfo.actionSetName, "quest"); std::strcpy(setInfo.localizedActionSetName, "Quest controllers"); + check(xrCreateActionSet(instance_, &setInfo, &actions_), "action set"); + auto action = [&](const char *name, XrActionType type, XrAction *handle) { + XrActionCreateInfo info{XR_TYPE_ACTION_CREATE_INFO}; + std::strcpy(info.actionName, name); std::strcpy(info.localizedActionName, name); + info.actionType = type; info.countSubactionPaths = 2; info.subactionPaths = hands_; + check(xrCreateAction(actions_, &info, handle), "create action"); + }; + action("grip_pose", XR_ACTION_TYPE_POSE_INPUT, &grip_); + action("trigger", XR_ACTION_TYPE_FLOAT_INPUT, &trigger_); + action("squeeze", XR_ACTION_TYPE_FLOAT_INPUT, &squeeze_); + action("stick", XR_ACTION_TYPE_VECTOR2F_INPUT, &stick_); + action("stick_click", XR_ACTION_TYPE_BOOLEAN_INPUT, &stickClick_); + action("primary", XR_ACTION_TYPE_BOOLEAN_INPUT, &primary_); + action("secondary", XR_ACTION_TYPE_BOOLEAN_INPUT, &secondary_); + action("menu", XR_ACTION_TYPE_BOOLEAN_INPUT, &menu_); + action("trigger_touch", XR_ACTION_TYPE_BOOLEAN_INPUT, &triggerTouch_); + action("stick_touch", XR_ACTION_TYPE_BOOLEAN_INPUT, &stickTouch_); + action("primary_touch", XR_ACTION_TYPE_BOOLEAN_INPUT, &primaryTouch_); + action("secondary_touch", XR_ACTION_TYPE_BOOLEAN_INPUT, &secondaryTouch_); + action("thumbrest_touch", XR_ACTION_TYPE_BOOLEAN_INPUT, &thumbrestTouch_); + action("vibration", XR_ACTION_TYPE_VIBRATION_OUTPUT, &vibration_); + std::vector bindings; + for (const char *hand : {"left", "right"}) { + std::string root = std::string("/user/hand/") + hand; + bindings.push_back({grip_, path((root + "/input/grip/pose").c_str())}); + bindings.push_back({trigger_, path((root + "/input/trigger/value").c_str())}); + bindings.push_back({triggerTouch_, path((root + "/input/trigger/touch").c_str())}); + bindings.push_back({squeeze_, path((root + "/input/squeeze/value").c_str())}); + bindings.push_back({stick_, path((root + "/input/thumbstick").c_str())}); + bindings.push_back({stickClick_, path((root + "/input/thumbstick/click").c_str())}); + bindings.push_back({stickTouch_, path((root + "/input/thumbstick/touch").c_str())}); + bindings.push_back({thumbrestTouch_, path((root + "/input/thumbrest/touch").c_str())}); + bindings.push_back({primary_, path((root + (std::strcmp(hand, "left") == 0 ? "/input/x/click" : "/input/a/click")).c_str())}); + bindings.push_back({secondary_, path((root + (std::strcmp(hand, "left") == 0 ? "/input/y/click" : "/input/b/click")).c_str())}); + bindings.push_back({primaryTouch_, path((root + (std::strcmp(hand, "left") == 0 ? "/input/x/touch" : "/input/a/touch")).c_str())}); + bindings.push_back({secondaryTouch_, path((root + (std::strcmp(hand, "left") == 0 ? "/input/y/touch" : "/input/b/touch")).c_str())}); + bindings.push_back({vibration_, path((root + "/output/haptic").c_str())}); + } + bindings.push_back({menu_, path("/user/hand/left/input/menu/click")}); + XrInteractionProfileSuggestedBinding suggestion{XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING}; + suggestion.interactionProfile = path("/interaction_profiles/oculus/touch_controller"); + suggestion.countSuggestedBindings = bindings.size(); suggestion.suggestedBindings = bindings.data(); + check(xrSuggestInteractionProfileBindings(instance_, &suggestion), "Touch bindings"); + XrSessionActionSetsAttachInfo attach{XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO}; + attach.countActionSets = 1; attach.actionSets = &actions_; + check(xrAttachSessionActionSets(session_, &attach), "attach actions"); + for (int hand = 0; hand < 2; hand++) { + XrActionSpaceCreateInfo space{XR_TYPE_ACTION_SPACE_CREATE_INFO}; + space.action = grip_; space.subactionPath = hands_[hand]; space.poseInActionSpace.orientation.w = 1; + check(xrCreateActionSpace(session_, &space, &handSpaces_[hand]), "controller space"); + } + } + + void initializeImages() { + uint32_t count = 0; + check(xrEnumerateViewConfigurationViews(instance_, system_, XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO, + 0, &count, nullptr), "view count"); + if (count != 2) throw std::runtime_error("Expected two stereo views"); + std::vector views(count, {XR_TYPE_VIEW_CONFIGURATION_VIEW}); + check(xrEnumerateViewConfigurationViews(instance_, system_, XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO, + count, &count, views.data()), "view configuration"); + check(xrEnumerateSwapchainFormats(session_, 0, &count, nullptr), "format count"); + std::vector formats(count); + check(xrEnumerateSwapchainFormats(session_, count, &count, formats.data()), "formats"); + int64_t format = 0; + for (int64_t candidate : formats) if (candidate == GL_SRGB8_ALPHA8) format = candidate; + if (!format) throw std::runtime_error("sRGB swapchain unavailable"); + for (int eye = 0; eye < 2; eye++) { + Eye &target = eyes_[eye]; + target.width = views[eye].recommendedImageRectWidth; + target.height = views[eye].recommendedImageRectHeight; + XrSwapchainCreateInfo create{XR_TYPE_SWAPCHAIN_CREATE_INFO}; + create.usageFlags = XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT; + create.format = format; create.sampleCount = 1; + create.width = target.width; create.height = target.height; + create.faceCount = 1; create.arraySize = 1; create.mipCount = 1; + check(xrCreateSwapchain(session_, &create, &target.swapchain), "swapchain"); + check(xrEnumerateSwapchainImages(target.swapchain, 0, &count, nullptr), "image count"); + target.images.resize(count, {XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR}); + check(xrEnumerateSwapchainImages(target.swapchain, count, &count, + reinterpret_cast(target.images.data())), "images"); + } + } + + void initializeTracking() { + std::string directory = std::string(app_->activity->internalDataPath) + "/.wayland-rt"; + if (mkdir(directory.c_str(), 0700) != 0 && errno != EEXIST) + throw std::runtime_error("XR tracking directory unavailable"); + auto mapFile = [&](const char *name, size_t size) { + std::string filename = directory + "/" + name; + int descriptor = open(filename.c_str(), O_CREAT | O_RDWR | O_CLOEXEC, 0600); + if (descriptor < 0) throw std::runtime_error("XR IPC file unavailable"); + if (ftruncate(descriptor, size) != 0) { + close(descriptor); throw std::runtime_error("XR IPC file size failed"); + } + void *mapping = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, descriptor, 0); + close(descriptor); + if (mapping == MAP_FAILED) throw std::runtime_error("XR IPC map failed"); + return mapping; + }; + tracking_ = static_cast(mapFile(DROIDDECK_XR_FILE, sizeof(DroidDeckXrTracking))); + haptics_ = static_cast(mapFile(DROIDDECK_XR_HAPTIC_FILE, sizeof(DroidDeckXrHaptics))); + haptics_->magic = DROIDDECK_XR_HAPTIC_MAGIC; haptics_->version = DROIDDECK_XR_VERSION; + for (int hand = 0; hand < 2; hand++) lastPulse_[hand] = haptics_->hands[hand].id; + } + + static DroidDeckXrPose posePacket(const XrPosef &pose, XrSpaceLocationFlags flags) { + return {{pose.orientation.x, pose.orientation.y, pose.orientation.z, pose.orientation.w}, + {pose.position.x, pose.position.y, pose.position.z}, (uint32_t)flags}; + } + + void publishTracking(const XrView views[2], XrTime predicted) { + if (!tracking_) return; + timespec now{}; clock_gettime(CLOCK_MONOTONIC, &now); + DroidDeckXrTracking packet{}; + packet.magic = DROIDDECK_XR_MAGIC; packet.version = DROIDDECK_XR_VERSION; + packet.active = state_ == XR_SESSION_STATE_VISIBLE || state_ == XR_SESSION_STATE_FOCUSED; + packet.sampled_ns = (int64_t)now.tv_sec * 1000000000LL + now.tv_nsec; + if (convertTime_) { + timespec displayTime{}; + check(convertTime_(instance_, predicted, &displayTime), "display time conversion"); + packet.predicted_ns = (int64_t)displayTime.tv_sec * 1000000000LL + displayTime.tv_nsec; + } + packet.period_ns = period_; + packet.head = posePacket(head_.pose, head_.locationFlags); + for (int eye = 0; eye < 2; eye++) { + packet.eyes[eye].pose = posePacket(views[eye].pose, head_.locationFlags); + packet.eyes[eye].fov[0] = views[eye].fov.angleLeft; + packet.eyes[eye].fov[1] = views[eye].fov.angleRight; + packet.eyes[eye].fov[2] = views[eye].fov.angleUp; + packet.eyes[eye].fov[3] = views[eye].fov.angleDown; + packet.eyes[eye].width = eyes_[eye].width; packet.eyes[eye].height = eyes_[eye].height; + packet.hands[eye] = inputs_[eye]; + packet.hands[eye].pose = posePacket(handLocations_[eye].pose, handLocations_[eye].locationFlags); + packet.hands[eye].active = handActive_[eye]; + } + uint32_t sequence = __atomic_load_n(&tracking_->seq, __ATOMIC_RELAXED); + __atomic_store_n(&tracking_->seq, sequence | 1u, __ATOMIC_SEQ_CST); + __atomic_thread_fence(__ATOMIC_SEQ_CST); + std::memcpy(tracking_, &packet, offsetof(DroidDeckXrTracking, seq)); + std::memcpy(reinterpret_cast(tracking_) + offsetof(DroidDeckXrTracking, active), + reinterpret_cast(&packet) + offsetof(DroidDeckXrTracking, active), + sizeof(packet) - offsetof(DroidDeckXrTracking, active)); + __atomic_store_n(&tracking_->seq, (sequence | 1u) + 1u, __ATOMIC_RELEASE); + } + + void attachGuest(bool attach) { + if (attach == guestAttached_) return; + env_->CallVoidMethod(app_->activity->clazz, activeCallback_, static_cast(attach)); + if (env_->ExceptionCheck()) { + env_->ExceptionDescribe(); env_->ExceptionClear(); throw std::runtime_error("Guest XR handshake failed"); + } + guestAttached_ = attach; + } + + void pollHaptics() { + if (!haptics_) return; + DroidDeckXrHaptics packet{}; + uint32_t sequence = __atomic_load_n(&haptics_->seq, __ATOMIC_ACQUIRE); + if (sequence & 1u) return; + std::memcpy(&packet, haptics_, sizeof(packet)); + __atomic_thread_fence(__ATOMIC_ACQUIRE); + if (__atomic_load_n(&haptics_->seq, __ATOMIC_RELAXED) != sequence + || packet.magic != DROIDDECK_XR_HAPTIC_MAGIC || packet.version != DROIDDECK_XR_VERSION) return; + for (int hand = 0; hand < 2; hand++) { + const auto &pulse = packet.hands[hand]; + if (pulse.id == lastPulse_[hand]) continue; + lastPulse_[hand] = pulse.id; + if (state_ != XR_SESSION_STATE_FOCUSED || !handActive_[hand] + || pulse.duration_ns < 1000000 || pulse.duration_ns > 1000000000 + || !std::isfinite(pulse.amplitude) || pulse.amplitude < 0 || pulse.amplitude > 1 + || !std::isfinite(pulse.frequency) || pulse.frequency < 0) continue; + XrHapticActionInfo info{XR_TYPE_HAPTIC_ACTION_INFO}; info.action = vibration_; info.subactionPath = hands_[hand]; + XrHapticVibration vibration{XR_TYPE_HAPTIC_VIBRATION}; + vibration.duration = pulse.duration_ns; vibration.amplitude = pulse.amplitude; vibration.frequency = pulse.frequency; + check(xrApplyHapticFeedback(session_, &info, reinterpret_cast(&vibration)), "guest haptics"); + } + } + + GLuint shader(GLenum type, const char *text) { + GLuint handle = glCreateShader(type); + glShaderSource(handle, 1, &text, nullptr); glCompileShader(handle); + GLint success = 0; glGetShaderiv(handle, GL_COMPILE_STATUS, &success); + if (!success) { glDeleteShader(handle); throw std::runtime_error("Shader compile failed"); } + return handle; + } + + void initializeGraphics() { + glGenFramebuffers(1, &framebuffer_); + glGenVertexArrays(1, &vertexArray_); + GLuint vertex = shader(GL_VERTEX_SHADER, + "#version 300 es\nout vec2 uv; uniform float eye; void main(){vec2 coordinate=vec2(float((gl_VertexID<<1)&2),float(gl_VertexID&2));uv=vec2(coordinate.x*0.5+eye*0.5,1.0-coordinate.y);gl_Position=vec4(coordinate*2.0-1.0,0.0,1.0);}"); + GLuint fragment = shader(GL_FRAGMENT_SHADER, + "#version 300 es\nprecision highp float; in vec2 uv; uniform sampler2D source; uniform float eye; out vec4 outputColor; void main(){float edge=0.5/float(textureSize(source,0).x);vec2 coordinate=vec2(clamp(uv.x,eye*0.5+edge,(eye+1.0)*0.5-edge),uv.y);outputColor=texture(source,coordinate);}"); + sourceProgram_ = glCreateProgram(); glAttachShader(sourceProgram_, vertex); glAttachShader(sourceProgram_, fragment); + glLinkProgram(sourceProgram_); glDeleteShader(vertex); glDeleteShader(fragment); + GLint linked = 0; glGetProgramiv(sourceProgram_, GL_LINK_STATUS, &linked); + if (!linked) throw std::runtime_error("Frame shader link failed"); + glGenTextures(1, &sourceTexture_); glBindTexture(GL_TEXTURE_2D, sourceTexture_); + cpuTexture_ = sourceTexture_; + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + } + + void receiveFrame() { + if (gpuFrames_.Take(sourceHeader_, sourceTexture_)) { + uploadedFrames_++; + if (uploadedFrames_ % 72 == 1) health(); + return; + } + DroidDeckXrPixels frame; + if (!receiver_.Take(&frame)) return; + GLint maximum = 0; glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maximum); + if (frame.header.width > static_cast(maximum) || frame.header.height > static_cast(maximum)) + throw std::runtime_error("XR source exceeds GPU texture limit"); + sourceTexture_ = cpuTexture_; + glBindTexture(GL_TEXTURE_2D, sourceTexture_); + GLenum encoding = frame.header.color_space == DROIDDECK_XR_COLOR_SRGB_RGBA8 ? GL_SRGB8_ALPHA8 : GL_RGBA8; + glTexImage2D(GL_TEXTURE_2D, 0, encoding, frame.header.width, frame.header.height, 0, + GL_RGBA, GL_UNSIGNED_BYTE, frame.pixels.data()); + if (verifyPixels_) { + glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_); + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, sourceTexture_, 0); + if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) + throw std::runtime_error("Frame readback framebuffer incomplete"); + std::vector readback(frame.header.bytes); + glReadPixels(0, 0, frame.header.width, frame.header.height, GL_RGBA, GL_UNSIGNED_BYTE, readback.data()); + if (readback != frame.pixels) throw std::runtime_error("Frame GPU readback does not match owned pixels"); + gpuChecksum_ = 2166136261u; + for (unsigned char value : readback) gpuChecksum_ = (gpuChecksum_ ^ value) * 16777619u; + verifiedFrame_ = frame.header.frame_id; + glBindFramebuffer(GL_FRAMEBUFFER, 0); + } + if (glGetError() != GL_NO_ERROR) throw std::runtime_error("Frame texture upload failed"); + sourceHeader_ = frame.header; + receiver_.Recycle(std::move(frame.pixels)); + uploadedFrames_++; + if (verifyPixels_ || uploadedFrames_ % 72 == 1) health(); + } + + void render(Eye &eye, uint32_t image) { + glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, eye.images[image].image, 0); + if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) + throw std::runtime_error("Incomplete eye framebuffer"); + { + glViewport(0, 0, eye.width, eye.height); glDisable(GL_DEPTH_TEST); + glUseProgram(sourceProgram_); glBindVertexArray(vertexArray_); + glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, sourceTexture_); + glUniform1i(glGetUniformLocation(sourceProgram_, "source"), 0); + glUniform1f(glGetUniformLocation(sourceProgram_, "eye"), &eye == &eyes_[1] ? 1.f : 0.f); + glDrawArrays(GL_TRIANGLES, 0, 3); + } + glBindFramebuffer(GL_FRAMEBUFFER, 0); + if (glGetError() != GL_NO_ERROR) throw std::runtime_error("OpenGL render error"); + glFlush(); + } + + void pollEvents() { + XrEventDataBuffer event{XR_TYPE_EVENT_DATA_BUFFER}; + XrResult result; + while ((result = xrPollEvent(instance_, &event)) == XR_SUCCESS) { + if (event.type == XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED) { + state_ = reinterpret_cast(&event)->state; + __android_log_print(ANDROID_LOG_INFO, "DroidDeckXR", "session state=%d", state_); + attachGuest(state_ == XR_SESSION_STATE_VISIBLE || state_ == XR_SESSION_STATE_FOCUSED); + if (state_ == XR_SESSION_STATE_READY) { + XrSessionBeginInfo begin{XR_TYPE_SESSION_BEGIN_INFO}; + begin.primaryViewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO; + check(xrBeginSession(session_, &begin), "xrBeginSession"); running_ = true; + if (setPerformance_) { + for (auto domain : {XR_PERF_SETTINGS_DOMAIN_CPU_EXT, XR_PERF_SETTINGS_DOMAIN_GPU_EXT}) { + XrResult request = setPerformance_(session_, domain, XR_PERF_SETTINGS_LEVEL_SUSTAINED_HIGH_EXT); + __android_log_print(ANDROID_LOG_INFO, "DroidDeckXR", "sustained performance domain=%d result=%d", domain, request); + } + } + } else if (state_ == XR_SESSION_STATE_STOPPING) { + check(xrEndSession(session_), "xrEndSession"); running_ = false; + if (quitRequested_) exit_ = true; + } else if (state_ == XR_SESSION_STATE_EXITING || state_ == XR_SESSION_STATE_LOSS_PENDING) exit_ = true; + health(); + } else if (event.type == XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING) exit_ = true; + else if (event.type == XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT) { + const auto &performance = *reinterpret_cast(&event); + __android_log_print(ANDROID_LOG_INFO, "DroidDeckXR", "performance domain=%d subdomain=%d level=%d->%d", + performance.domain, performance.subDomain, performance.fromLevel, performance.toLevel); + } + event = {XR_TYPE_EVENT_DATA_BUFFER}; + } + check(result, "xrPollEvent"); + } + + void frame() { + XrFrameWaitInfo wait{XR_TYPE_FRAME_WAIT_INFO}; + XrFrameState frameState{XR_TYPE_FRAME_STATE}; + check(xrWaitFrame(session_, &wait, &frameState), "xrWaitFrame"); + period_ = frameState.predictedDisplayPeriod; + XrFrameBeginInfo begin{XR_TYPE_FRAME_BEGIN_INFO}; check(xrBeginFrame(session_, &begin), "xrBeginFrame"); + check(xrLocateSpace(view_, world_, frameState.predictedDisplayTime, &head_), "head pose"); + if (state_ == XR_SESSION_STATE_FOCUSED) { + XrActiveActionSet active{actions_, XR_NULL_PATH}; + XrActionsSyncInfo sync{XR_TYPE_ACTIONS_SYNC_INFO}; sync.countActiveActionSets = 1; sync.activeActionSets = &active; + check(xrSyncActions(session_, &sync), "xrSyncActions"); + for (int hand = 0; hand < 2; hand++) { + XrActionStateGetInfo get{XR_TYPE_ACTION_STATE_GET_INFO}; get.action = grip_; get.subactionPath = hands_[hand]; + XrActionStatePose pose{XR_TYPE_ACTION_STATE_POSE}; check(xrGetActionStatePose(session_, &get, &pose), "grip state"); + handActive_[hand] = pose.isActive; + check(xrLocateSpace(handSpaces_[hand], world_, frameState.predictedDisplayTime, &handLocations_[hand]), "hand pose"); + get.action = trigger_; + XrActionStateFloat trigger{XR_TYPE_ACTION_STATE_FLOAT}; check(xrGetActionStateFloat(session_, &get, &trigger), "trigger state"); + inputs_[hand].trigger = trigger.isActive ? trigger.currentState : 0; + get.action = squeeze_; + XrActionStateFloat squeeze{XR_TYPE_ACTION_STATE_FLOAT}; check(xrGetActionStateFloat(session_, &get, &squeeze), "squeeze state"); + inputs_[hand].squeeze = squeeze.isActive ? squeeze.currentState : 0; + get.action = stick_; + XrActionStateVector2f stick{XR_TYPE_ACTION_STATE_VECTOR2F}; check(xrGetActionStateVector2f(session_, &get, &stick), "stick state"); + inputs_[hand].stick[0] = stick.isActive ? stick.currentState.x : 0; + inputs_[hand].stick[1] = stick.isActive ? stick.currentState.y : 0; + inputs_[hand].buttons = 0; + const std::pair buttons[] = { + {stickClick_, DROIDDECK_XR_STICK_CLICK}, {primary_, DROIDDECK_XR_PRIMARY_CLICK}, + {secondary_, DROIDDECK_XR_SECONDARY_CLICK}, {menu_, DROIDDECK_XR_MENU_CLICK}, + {triggerTouch_, DROIDDECK_XR_TRIGGER_TOUCH}, {stickTouch_, DROIDDECK_XR_STICK_TOUCH}, + {primaryTouch_, DROIDDECK_XR_PRIMARY_TOUCH}, {secondaryTouch_, DROIDDECK_XR_SECONDARY_TOUCH}, + {thumbrestTouch_, DROIDDECK_XR_THUMBREST_TOUCH}}; + for (const auto &button : buttons) { + get.action = button.first; + XrActionStateBoolean value{XR_TYPE_ACTION_STATE_BOOLEAN}; check(xrGetActionStateBoolean(session_, &get, &value), "button state"); + if (value.isActive && value.currentState) inputs_[hand].buttons |= button.second; + } + } + } else handActive_[0] = handActive_[1] = false; + pollHaptics(); + XrViewLocateInfo locate{XR_TYPE_VIEW_LOCATE_INFO}; locate.viewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO; + locate.displayTime = frameState.predictedDisplayTime; locate.space = world_; + XrViewState viewState{XR_TYPE_VIEW_STATE}; uint32_t count = 0; + XrView views[2]{{XR_TYPE_VIEW}, {XR_TYPE_VIEW}}; + check(xrLocateViews(session_, &locate, &viewState, 2, &count, views), "xrLocateViews"); + publishTracking(views, frameState.predictedDisplayTime); + if (guestAttached_) { + timespec now{}; clock_gettime(CLOCK_MONOTONIC, &now); + env_->CallVoidMethod(app_->activity->clazz, frameCallback_, (jlong)now.tv_sec * 1000000000LL + now.tv_nsec); + if (env_->ExceptionCheck()) { env_->ExceptionClear(); throw std::runtime_error("Guest frame callback failed"); } + } + XrCompositionLayerProjectionView projection[2]{{XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW}, {XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW}}; + bool valid = frameState.shouldRender && count == 2 && + (viewState.viewStateFlags & (XR_VIEW_STATE_ORIENTATION_VALID_BIT | XR_VIEW_STATE_POSITION_VALID_BIT)) + == (XR_VIEW_STATE_ORIENTATION_VALID_BIT | XR_VIEW_STATE_POSITION_VALID_BIT); + { + valid = valid && sourceHeader_.frame_id && xr_frame_now() - sourceHeader_.captured_ns < 500000000LL; + if (valid) for (int eye = 0; eye < 2; eye++) { + auto source = xr_frame_view(sourceHeader_, eye); + views[eye].pose.orientation = {source.orientation[0], source.orientation[1], source.orientation[2], source.orientation[3]}; + views[eye].pose.position = {source.position[0], source.position[1], source.position[2]}; + views[eye].fov = {source.fov[0], source.fov[1], source.fov[2], source.fov[3]}; + } + } + const std::string capture = captureRequest(); + bool captured = valid; + if (!capture.empty() && valid) + captured = captureTexture(sourceTexture_, sourceHeader_.width, sourceHeader_.height, "source"); + if (valid) for (int eye = 0; eye < 2; eye++) { + uint32_t image = 0; + XrSwapchainImageAcquireInfo acquire{XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO}; + check(xrAcquireSwapchainImage(eyes_[eye].swapchain, &acquire, &image), "acquire image"); + XrSwapchainImageWaitInfo imageWait{XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO}; imageWait.timeout = XR_INFINITE_DURATION; + check(xrWaitSwapchainImage(eyes_[eye].swapchain, &imageWait), "wait image"); + render(eyes_[eye], image); + if (!capture.empty()) captured = captureTexture(eyes_[eye].images[image].image, eyes_[eye].width, eyes_[eye].height, eye ? "right" : "left") && captured; + XrSwapchainImageReleaseInfo release{XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO}; + check(xrReleaseSwapchainImage(eyes_[eye].swapchain, &release), "release image"); + projection[eye].pose = views[eye].pose; projection[eye].fov = views[eye].fov; + projection[eye].subImage.swapchain = eyes_[eye].swapchain; + projection[eye].subImage.imageRect.extent = {eyes_[eye].width, eyes_[eye].height}; + } + XrCompositionLayerProjection layer{XR_TYPE_COMPOSITION_LAYER_PROJECTION}; + layer.space = world_; layer.viewCount = 2; layer.views = projection; + const XrCompositionLayerBaseHeader *layers[] = {reinterpret_cast(&layer)}; + XrFrameEndInfo end{XR_TYPE_FRAME_END_INFO}; end.displayTime = frameState.predictedDisplayTime; + end.environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_OPAQUE; end.layerCount = valid ? 1 : 0; end.layers = layers; + check(xrEndFrame(session_, &end), "xrEndFrame"); + if (!capture.empty()) captureResult(capture, captured, valid, projection, frameState.predictedDisplayTime); + frames_++; if (valid) rendered_++; + if (frames_ % 72 == 0) { + health(); + __android_log_print(ANDROID_LOG_INFO, "DroidDeckXR", "frames=%llu rendered=%llu head=%llu hands=%d,%d period=%lld", + (unsigned long long)frames_, (unsigned long long)rendered_, (unsigned long long)head_.locationFlags, + handActive_[0], handActive_[1], (long long)period_); + } + } + + void cleanup() { + receiver_.Stop(); + gpuFrames_.Stop(); + try { attachGuest(false); } catch (const std::exception &error) { + __android_log_print(ANDROID_LOG_ERROR, "DroidDeckXR", "cleanup: %s", error.what()); + } + if (tracking_) { + __atomic_store_n(&tracking_->active, 0u, __ATOMIC_RELEASE); + munmap(tracking_, sizeof(DroidDeckXrTracking)); + } + if (haptics_) munmap(haptics_, sizeof(DroidDeckXrHaptics)); + if (display_ != EGL_NO_DISPLAY && context_ != EGL_NO_CONTEXT) { + glDeleteFramebuffers(1, &framebuffer_); glDeleteVertexArrays(1, &vertexArray_); + glDeleteTextures(1, &cpuTexture_); glDeleteProgram(sourceProgram_); + } + for (auto &eye : eyes_) if (eye.swapchain) xrDestroySwapchain(eye.swapchain); + for (auto space : handSpaces_) if (space) xrDestroySpace(space); + if (view_) xrDestroySpace(view_); if (world_) xrDestroySpace(world_); + if (session_) xrDestroySession(session_); + if (actions_) xrDestroyActionSet(actions_); + if (instance_) xrDestroyInstance(instance_); + if (display_ != EGL_NO_DISPLAY) { + eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + if (surface_ != EGL_NO_SURFACE) eglDestroySurface(display_, surface_); + if (context_ != EGL_NO_CONTEXT) eglDestroyContext(display_, context_); + eglTerminate(display_); + } + if (env_) app_->activity->vm->DetachCurrentThread(); + } +}; + +void android_main(android_app *app) { + QuestXR runtime(app); + try { runtime.run(); } + catch (const std::exception &error) { + __android_log_print(ANDROID_LOG_ERROR, "DroidDeckXR", "%s", error.what()); + runtime.health(error.what()); + ANativeActivity_finish(app->activity); + } +} diff --git a/app/src/main/cpp/viture/display_modes.h b/app/src/main/cpp/viture/display_modes.h new file mode 100644 index 0000000000..3a78e03aee --- /dev/null +++ b/app/src/main/cpp/viture/display_modes.h @@ -0,0 +1,36 @@ +#pragma once + +// Our controller uses the standard display-mode vocabulary, even for Beast. +// Native mode reuses some numbers with different meanings; never pass them through. +namespace droiddeck::viture { +constexpr int to_native_mode(int standard) { + switch (standard) { + case 0x31: return 0x31; // 1080p 60 + case 0x33: return 0x32; // 1080p 90 + case 0x34: return 0x33; // 1080p 120 + case 0x32: return 0x37; // 1080p SBS 60 + case 0x35: return 0x38; // 1080p SBS 90 + case 0x41: return 0x34; // 1200p 60 + case 0x43: return 0x35; // 1200p 90 + case 0x44: return 0x36; // 1200p 120 + case 0x42: return 0x3a; // 1200p SBS 60 + case 0x45: return 0x3b; // 1200p SBS 90 + default: return -4; + } +} +constexpr int from_native_mode(int native) { + switch (native) { + case 0x31: return 0x31; + case 0x32: return 0x33; + case 0x33: return 0x34; + case 0x37: return 0x32; + case 0x38: return 0x35; + case 0x34: return 0x41; + case 0x35: return 0x43; + case 0x36: return 0x44; + case 0x3a: return 0x42; + case 0x3b: return 0x45; + default: return -4; // Ultrawide is not stereo. + } +} +} diff --git a/app/src/main/cpp/viture/mjpeg_payload.h b/app/src/main/cpp/viture/mjpeg_payload.h new file mode 100644 index 0000000000..a451a4eeea --- /dev/null +++ b/app/src/main/cpp/viture/mjpeg_payload.h @@ -0,0 +1,11 @@ +#pragma once +#include +#include + +inline std::size_t mjpeg_payload_size(const uint8_t* bytes, std::size_t size) { + if (!bytes || size < 4 || size > 4*1024*1024 || bytes[0] != 0xff || bytes[1] != 0xd8) return 0; + std::size_t end = size; + // Luma Ultra UVC frames can pad the JPEG to an eight-byte boundary with zeros. + while (end > 4 && size-end < 7 && bytes[end-1] == 0) --end; + return bytes[end-2] == 0xff && bytes[end-1] == 0xd9 ? end : 0; +} diff --git a/app/src/main/cpp/viture/sdk_bridge.cpp b/app/src/main/cpp/viture/sdk_bridge.cpp new file mode 100644 index 0000000000..053c283358 --- /dev/null +++ b/app/src/main/cpp/viture/sdk_bridge.cpp @@ -0,0 +1,556 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "viture_glasses_provider.h" +#include "viture_device.h" +#include "viture_device_carina.h" +#include "viture_camera_provider.h" +#include "viture_protocol_public.h" +#include "viture_result.h" +#include "viture_version.h" +#include "display_modes.h" +#include "stereo_frame_gate.h" + +namespace { +// SDK callbacks have no user-data parameter. Only one provider may exist at a time. +std::mutex api_mutex; +std::mutex pose_mutex; +std::array latest_pose{}; +int64_t latest_time = 0; +bool accepting_pose = false; +bool accepting_state = false; +std::array state_values{}; +unsigned state_pending = 0; + +void on_state(int id, int value) { + std::lock_guard lock(pose_mutex); + if (!accepting_state || id < 0 || id >= int(state_values.size())) return; + state_values[id] = value; + state_pending |= 1u << id; +} + +void clear_state(bool accept) { + std::lock_guard lock(pose_mutex); + accepting_state = accept; + state_pending = 0; +} + +int64_t now_ns() { + timespec ts{}; + clock_gettime(CLOCK_BOOTTIME, &ts); + return int64_t(ts.tv_sec) * 1000000000LL + ts.tv_nsec; +} + +void on_pose(float* data, uint64_t) { + if (!data) return; + std::lock_guard lock(pose_mutex); + if (!accepting_pose) return; + std::copy_n(data + 3, 4, latest_pose.begin()); + // SDK device ticks are not Android's elapsed-realtime clock. + latest_time = now_ns(); +} + +void clear_pose(bool accept) { + std::lock_guard lock(pose_mutex); + accepting_pose = accept; + latest_time = 0; +} + +int64_t monotonic_ns() { + timespec ts{}; clock_gettime(CLOCK_MONOTONIC, &ts); + return int64_t(ts.tv_sec) * 1000000000LL + ts.tv_nsec; +} +struct CameraPose { double time; std::array pose; }; +std::mutex camera_mutex; +std::deque camera_poses; +std::vector camera_left, camera_right; +bool camera_accepting = false, camera_wanted = false; +int camera_width = 0, camera_height = 0; +uint64_t camera_sequence = 0, camera_consumed = 0; +StereoFrameGate camera_gate; +uint64_t camera_input_sequence = 0; +int64_t camera_receipt = 0; +int64_t camera_pose_receipt = 0; +double camera_source = 0; +const CameraPose *matched_camera_pose(double source) { + const CameraPose *best = nullptr; + double distance = 0.005; + for (const auto &p : camera_poses) if (std::abs(p.time-source) < distance) { + best = &p; distance = std::abs(p.time-source); + } + return best; +} +void on_carina_pose(float *pose, double stamp) { + if (!pose || !std::isfinite(stamp)) return; + std::lock_guard lock(camera_mutex); + if (!camera_accepting) return; + camera_pose_receipt = monotonic_ns(); + CameraPose p{stamp, {}}; std::copy_n(pose, 7, p.pose.begin()); + camera_poses.push_back(p); + while (camera_poses.size() > 64) camera_poses.pop_front(); +} +void on_camera(char *left, char *right, char *, char *, double stamp, int width, int height) { + if (!left || !right || width <= 0 || height <= 0 || width > 2048 || height > 2048 || !std::isfinite(stamp)) return; + const auto received = monotonic_ns(); + std::lock_guard lock(camera_mutex); + if (!camera_accepting || !camera_wanted) return; + if (!camera_gate.Accept(stamp)) return; + const size_t size = size_t(width) * height; + camera_left.resize(size); camera_right.resize(size); + memcpy(camera_left.data(), left, size); memcpy(camera_right.data(), right, size); + camera_width = width; camera_height = height; camera_source = stamp; camera_receipt = received; + camera_input_sequence = camera_gate.received; + ++camera_sequence; +} +void clear_camera(bool enabled) { + std::lock_guard lock(camera_mutex); + camera_accepting = enabled; camera_wanted = false; + camera_poses.clear(); camera_left.clear(); camera_right.clear(); + camera_sequence = camera_consumed = 0; + camera_gate = {}; camera_input_sequence = 0; + camera_pose_receipt = 0; +} + +struct Session { + XRDeviceProviderHandle device = nullptr; + int pid = 0; + int type = -1; + bool initialized = false; + bool started = false; + bool tracking = false; + bool native_dof = false; + bool switched_native = false; + int original_bypass_display = -1; + int saved_dof = -1; + int64_t consumed_time = 0; + jlong token = 0; + int spatial_status = 1; +}; +std::unique_ptr session; +jlong next_token = 0; + +void report(const char* step, int rc) { + if (rc < 0) __android_log_print(ANDROID_LOG_WARN, "VitureSdk", "%s: %d", step, rc); +} + +int suspend_native_dof(Session& s) { + if (!s.native_dof) return 0; + int mode = xr_device_provider_native_get_mode(s.device); + if (mode < 0) return mode; + if (mode != 1) return 0; + if (s.saved_dof < 0) { + int dof = xr_device_provider_native_get_dof(s.device); + if (dof < 0) return dof; + s.saved_dof = dof; + } + return xr_device_provider_native_set_dof(s.device, VITURE_NATIVE_DOF_0); +} + +void restore_native_dof(Session& s) { + if (s.saved_dof >= 0 && xr_device_provider_native_get_mode(s.device) == 1) { + report("restore native DOF", xr_device_provider_native_set_dof(s.device, s.saved_dof)); + } + s.saved_dof = -1; +} + +int tracking(Session& s, bool enabled) { + if (s.tracking == enabled) return 0; + if (!enabled) { + clear_pose(false); + int rc = s.type == XR_DEVICE_TYPE_VITURE_CARINA ? 0 : + xr_device_provider_close_imu(s.device, VITURE_IMU_MODE_POSE); + s.tracking = false; + restore_native_dof(s); + return rc; + } + int rc = suspend_native_dof(s); + if (rc < 0) return rc; + clear_pose(true); + s.consumed_time = 0; + if (s.type != XR_DEVICE_TYPE_VITURE_CARINA) { + int frequency = VITURE_IMU_FREQUENCY_MEDIUM_HIGH; + while (frequency >= VITURE_IMU_FREQUENCY_LOW && + !xr_device_provider_is_product_support_imu_frequency(s.pid, VITURE_IMU_MODE_POSE, frequency)) --frequency; + rc = frequency < 0 ? VITURE_GLASSES_ERROR_NOT_SUPPORTED : + xr_device_provider_open_imu(s.device, VITURE_IMU_MODE_POSE, frequency); + } + if (rc == 0) s.tracking = true; + else { clear_pose(false); restore_native_dof(s); } + return rc; +} + +void destroy(Session& s) { + clear_camera(false); + clear_pose(false); + clear_state(false); + if (s.device) { + if (s.tracking) report("close tracking", tracking(s, false)); + if (s.switched_native && s.original_bypass_display >= 0) { + int rc = xr_device_provider_native_set_mode(s.device, 0); + if (rc == 0) rc = xr_device_provider_set_display_mode(s.device, s.original_bypass_display); + report("restore bypass mode", rc); + } + if (s.started) report("stop", xr_device_provider_stop(s.device)); + if (s.initialized) report("shutdown", xr_device_provider_shutdown(s.device)); + xr_device_provider_destroy(s.device); + s.device = nullptr; + } +} + +int get_display(Session& s) { + if (s.native_dof) { + const int mode = xr_device_provider_native_get_mode(s.device); + if (mode < 0) return mode; + if (mode == 1) { + const int value = xr_device_provider_native_get_display_mode(s.device); + return value < 0 ? value : droiddeck::viture::from_native_mode(value); + } + } + return xr_device_provider_get_display_mode(s.device); +} + +int set_display(Session& s, int standard) { + if (!s.native_dof) return xr_device_provider_set_display_mode(s.device, standard); + int mode = xr_device_provider_native_get_mode(s.device); + if (mode < 0) return mode; + if (mode == 0) { + int rc = xr_device_provider_set_display_mode(s.device, standard); + if (rc != VITURE_GLASSES_ERROR_NOT_SUPPORTED) return rc; + // Older Beast firmware exposes fewer bypass modes. Fall back to its + // separate native table only when the SDK explicitly rejects the mode. + } + const int native = droiddeck::viture::to_native_mode(standard); + if (native < 0) return native; + if (mode == 0) { + if (!s.switched_native) { + s.original_bypass_display = xr_device_provider_get_display_mode(s.device); + if (s.original_bypass_display < 0) return s.original_bypass_display; + } + int rc = xr_device_provider_native_set_mode(s.device, 1); + if (rc < 0) return rc; + s.switched_native = true; + } + int rc = xr_device_provider_native_set_display_mode(s.device, native); + if (rc == 0 && s.tracking) rc = suspend_native_dof(s); + if (rc < 0 && mode == 0) { + restore_native_dof(s); + int rollback = xr_device_provider_native_set_mode(s.device, 0); + if (rollback == 0) rollback = xr_device_provider_set_display_mode(s.device, s.original_bypass_display); + report("rollback display mode", rollback); + if (rollback == 0) s.switched_native = false; + } + return rc; +} +} + +#define JNI_METHOD(name) Java_com_droiddeck_launcher_glasses_VitureSdk_##name +extern "C" JNIEXPORT jboolean JNICALL JNI_METHOD(nativeAvailable)(JNIEnv*, jobject) { + __android_log_print(ANDROID_LOG_INFO, "VitureSdk", "SDK %s", GetVersionString()); + return JNI_TRUE; +} + +extern "C" JNIEXPORT jstring JNICALL JNI_METHOD(nativeMarketName)(JNIEnv* env, jobject, jint pid) { + std::lock_guard lock(api_mutex); + if (!xr_device_provider_is_product_id_valid(pid)) return nullptr; + char name[64]{}; + int length = sizeof(name) - 1; + if (xr_device_provider_get_market_name(pid, name, &length) != 0) return nullptr; + name[sizeof(name) - 1] = 0; + return env->NewStringUTF(name); +} + +extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativeOpen)(JNIEnv* env, jobject, jint pid, jint fd, jstring cache, jboolean spatial) { + std::lock_guard lock(api_mutex); + if (session || fd < 0 || !cache || !xr_device_provider_is_product_id_valid(pid)) return 0; + auto s = std::make_unique(); + s->pid = pid; + s->device = xr_device_provider_create(pid, fd); + if (!s->device) return 0; + s->type = xr_device_provider_get_device_type(s->device); + s->native_dof = xr_device_provider_is_product_support_native_dof(pid) == 1; + int rc = s->type < 0 ? s->type : 0; + if (rc == 0) { + clear_state(true); + rc = xr_device_provider_register_state_callback(s->device, on_state); + } + if (rc == 0) { + rc = s->type == XR_DEVICE_TYPE_VITURE_CARINA ? + xr_device_provider_set_dof_type_carina(s->device, spatial ? 1 : 0) : + xr_device_provider_register_imu_pose_callback(s->device, on_pose); + } + if (rc == 0) { + const char* directory = env->GetStringUTFChars(cache, nullptr); + if (!directory) { destroy(*s); return 0; } + rc = xr_device_provider_initialize(s->device, nullptr, directory); + env->ReleaseStringUTFChars(cache, directory); + s->initialized = rc == 0; + } + if (rc == 0 && s->type == XR_DEVICE_TYPE_VITURE_CARINA && spatial) { + clear_camera(true); + rc = xr_device_provider_register_callbacks_carina(s->device, on_carina_pose, nullptr, nullptr, on_camera); + } + if (rc == 0) { + rc = xr_device_provider_start(s->device); + s->started = rc == 0; + } + if (rc != 0) { report("initialize/start", rc); destroy(*s); return 0; } + s->token = ++next_token; + session = std::move(s); + return session->token; +} + +extern "C" JNIEXPORT jint JNICALL JNI_METHOD(nativeType)(JNIEnv*, jobject, jlong token) { + std::lock_guard lock(api_mutex); + return session && session->token == token ? session->type : -1; +} + +extern "C" JNIEXPORT jint JNICALL JNI_METHOD(nativeTracking)(JNIEnv*, jobject, jlong token, jboolean enabled) { + std::lock_guard lock(api_mutex); + return session && session->token == token ? tracking(*session, enabled) : -1; +} + +extern "C" JNIEXPORT jint JNICALL JNI_METHOD(nativeCommand)(JNIEnv*, jobject, jlong token, jint command, jint value) { + std::lock_guard lock(api_mutex); + if (!session || session->token != token) return -1; + auto& s = *session; + switch (command) { + case 1: return get_display(s); + case 2: return set_display(s, value); + case 3: return xr_device_provider_get_brightness_level(s.device); + case 4: return xr_device_provider_set_brightness_level(s.device, value); + case 5: return xr_device_provider_get_volume_level(s.device); + case 6: return xr_device_provider_set_volume_level(s.device, value); + case 7: return xr_device_provider_set_film_mode(s.device, value ? 1.0f : 0.0f); + default: return VITURE_GLASSES_ERROR_NOT_SUPPORTED; + } +} + +extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativePose)(JNIEnv* env, jobject, jlong token, jfloatArray output) { + std::lock_guard lock(api_mutex); + if (!session || session->token != token || !output || env->GetArrayLength(output) != 4) return -1; + auto& s = *session; + if (!s.tracking) return 0; + if (s.type == XR_DEVICE_TYPE_VITURE_CARINA) { + float pose[7]{}; + int status = 1; + int rc = xr_device_provider_get_gl_pose_carina(s.device, pose, 0.0, &status); + if (rc < 0) return rc; + if (status != 0) return 0; + env->SetFloatArrayRegion(output, 0, 4, pose + 3); + return now_ns(); + } + std::lock_guard pose_lock(pose_mutex); + if (!latest_time || latest_time == s.consumed_time) return 0; + env->SetFloatArrayRegion(output, 0, 4, latest_pose.data()); + s.consumed_time = latest_time; + return latest_time; +} + +extern "C" JNIEXPORT jint JNICALL JNI_METHOD(nativeNextState)(JNIEnv* env, jobject, jlong token, jintArray output) { + std::lock_guard lock(api_mutex); + if (!session || session->token != token || !output || env->GetArrayLength(output) != 2) return -1; + std::lock_guard state_lock(pose_mutex); + for (int id = 0; id < int(state_values.size()); ++id) { + if (!(state_pending & (1u << id))) continue; + state_pending &= ~(1u << id); + const jint value[] = {id, state_values[id]}; + env->SetIntArrayRegion(output, 0, 2, value); + return 1; + } + return 0; +} + +extern "C" JNIEXPORT void JNICALL JNI_METHOD(nativeClose)(JNIEnv*, jobject, jlong token) { + std::lock_guard lock(api_mutex); + if (session && session->token == token) { destroy(*session); session.reset(); } +} + +extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativeSpatialPose)(JNIEnv* env, jobject, jlong token, + jfloatArray output, jintArray state) { + std::lock_guard lock(api_mutex); + if (!session || session->token != token || !session->tracking || session->type != XR_DEVICE_TYPE_VITURE_CARINA || + !output || !state || env->GetArrayLength(output) != 7 || env->GetArrayLength(state) != 1) return 0; + float pose[7]{}; int status = 1; + int rc = xr_device_provider_get_gl_pose_carina(session->device, pose, 0.0, &status); + session->spatial_status = rc == 0 ? status : rc; + jint valid = rc == 0 ? status : rc; + if (valid == 0) { + std::lock_guard lock(camera_mutex); + if (monotonic_ns()-camera_pose_receipt > 100000000LL) valid = 1; + } + env->SetIntArrayRegion(state, 0, 1, &valid); + env->SetFloatArrayRegion(output, 0, 7, pose); + return monotonic_ns(); +} +extern "C" JNIEXPORT void JNICALL JNI_METHOD(nativeCapture)(JNIEnv*, jobject, jlong token, jboolean wanted, jint ratePermille) { + std::lock_guard api(api_mutex); + if (!session || session->token != token) return; + std::lock_guard lock(camera_mutex); + camera_wanted = wanted; + camera_gate.SetRatePermille(wanted ? ratePermille : 1000); + if (!wanted) camera_consumed = camera_sequence; +} +extern "C" JNIEXPORT jstring JNICALL JNI_METHOD(nativeFirmware)(JNIEnv* env, jobject, jlong token) { + std::lock_guard api(api_mutex); + if (!session || session->token != token) return nullptr; + char value[256]{}; int length = 255; + if (xr_device_provider_get_glasses_version(session->device, value, &length) != 0) return nullptr; + value[255] = 0; + return env->NewStringUTF(value); +} +extern "C" JNIEXPORT jbyteArray JNICALL JNI_METHOD(nativeSerialHash)(JNIEnv* env, jobject, jlong token) { + std::lock_guard api(api_mutex); + if (!session || session->token != token) return nullptr; + uint8_t hash[32]{}; + const int rc = xr_device_provider_get_sn_hash(session->device, hash); + if (rc != 0) { report("read device identity", rc); return nullptr; } + auto result = env->NewByteArray(32); + if (result) env->SetByteArrayRegion(result, 0, 32, reinterpret_cast(hash)); + return result; +} +extern "C" JNIEXPORT jdoubleArray JNICALL JNI_METHOD(nativeSpatialDiagnostics)(JNIEnv* env, jobject, jlong token) { + std::lock_guard api(api_mutex); + if (!session || session->token != token) return nullptr; + std::lock_guard lock(camera_mutex); + double values[3] = {double(session->spatial_status), camera_pose_receipt ? (monotonic_ns()-camera_pose_receipt)/1e6 : -1.0, + camera_poses.empty() ? -1.0 : (camera_poses.back().time-camera_source)*1000.0}; + auto result=env->NewDoubleArray(3); + if(result)env->SetDoubleArrayRegion(result,0,3,values); + return result; +} +extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativeStereo)(JNIEnv* env, jobject, jlong token, + jobject left, jobject right, jdoubleArray metadata, jfloatArray head, jboolean waitForPose) { + std::lock_guard api(api_mutex); + if (!session || session->token != token || !left || !right || !metadata || !head || + env->GetArrayLength(metadata) != 9 || env->GetArrayLength(head) != 7) return 0; + std::lock_guard lock(camera_mutex); + if (!camera_wanted || camera_sequence == camera_consumed || camera_left.empty()) return 0; + const auto size = camera_left.size(); + if (env->GetDirectBufferCapacity(left) < jlong(size) || env->GetDirectBufferCapacity(right) < jlong(size)) return -1; + auto l = env->GetDirectBufferAddress(left), r = env->GetDirectBufferAddress(right); + if (!l || !r) return -1; + const CameraPose *best = matched_camera_pose(camera_source); + if (waitForPose && !best && monotonic_ns()-camera_receipt < 35000000LL) return 0; + memcpy(l, camera_left.data(), size); memcpy(r, camera_right.data(), size); + double meta[9] = {double(camera_width), double(camera_height), camera_source, double(camera_receipt), + double(token), double(camera_sequence), best ? 1.0 : 0.0, + double(camera_input_sequence), double(camera_gate.skipped)}; + env->SetDoubleArrayRegion(metadata, 0, 9, meta); + if (best) env->SetFloatArrayRegion(head, 0, 7, best->pose.data()); + camera_consumed = camera_sequence; + return jlong(camera_sequence); +} +extern "C" JNIEXPORT jboolean JNICALL JNI_METHOD(nativeCameraSynchronized)(JNIEnv*, jobject, jlong token, jdouble source) { + std::lock_guard api(api_mutex); + if (!session || session->token != token || !std::isfinite(source)) return JNI_FALSE; + std::lock_guard lock(camera_mutex); + return camera_accepting && matched_camera_pose(source) != nullptr; +} + +namespace { +struct RgbUsbLog { + int savedStderr; + bool hadLevel; + std::string oldLevel; + explicit RgbUsbLog(int fd) : savedStderr(dup(STDERR_FILENO)), + hadLevel(getenv("LIBUSB_DEBUG") != nullptr), oldLevel(hadLevel ? getenv("LIBUSB_DEBUG") : "") { + fflush(stderr); + if (savedStderr >= 0) dup2(fd, STDERR_FILENO); + setenv("LIBUSB_DEBUG", "4", 1); + } + ~RgbUsbLog() { + fflush(stderr); + if (savedStderr >= 0) { dup2(savedStderr, STDERR_FILENO); close(savedStderr); } + if (hadLevel) setenv("LIBUSB_DEBUG", oldLevel.c_str(), 1); else unsetenv("LIBUSB_DEBUG"); + } +}; + +void rgb_usb_state(int fd, const char* stage) { + uint8_t alternate = 0; + usbdevfs_ctrltransfer request{}; + request.bRequestType=0x81; request.bRequest=0x0a; request.wIndex=1; + request.wLength=1; request.timeout=200; request.data=&alternate; + int result=ioctl(fd, USBDEVFS_CONTROL, &request); + fprintf(stderr,"RGB %s GET_INTERFACE result=%d errno=%d alternate=%u\n",stage,result,result<0 ? errno : 0,alternate); + for (int selector : {1, 2}) { + uint8_t size[2]{}; + request.bRequestType=0xa1; request.bRequest=0x85; request.wValue=selector << 8; + request.wLength=2; request.data=size; + result=ioctl(fd,USBDEVFS_CONTROL,&request); + const unsigned length=result==2 ? unsigned(size[0]) | unsigned(size[1]) << 8 : 26; + uint8_t bytes[64]{}; + request.bRequest=0x81; request.wLength=std::clamp(length,26u,64u); request.data=bytes; + result=ioctl(fd,USBDEVFS_CONTROL,&request); + fprintf(stderr,"RGB %s %s result=%d errno=%d bytes=",stage,selector==1 ? "PROBE" : "COMMIT",result,result<0 ? errno : 0); + for (int i=0;iGetArrayLength(metadata) != 7 || + !xr_camera_provider_is_valid_camera(vid, pid)) return nullptr; + RgbUsbLog usbLog(logFd); + rgb_usb_state(fd,"before-create"); + struct Capture { + std::mutex mutex; + std::condition_variable ready; + std::vector jpeg; + unsigned frames = 0; + jlong values[7]{}; + } capture; + auto camera = xr_camera_provider_create(vid, pid, fd); + if (!camera) { fprintf(stderr,"RGB provider create failed\n"); return nullptr; } + const int result = xr_camera_provider_start(camera, [](const XRCameraFrame* frame, void* data) { + auto& c = *static_cast(data); + std::lock_guard lock(c.mutex); + ++c.frames; + if (!frame || !frame->data || frame->format != XR_CAMERA_FORMAT_MJPEG || + frame->size < 4 || frame->size > 4 * 1024 * 1024) return; + c.jpeg.assign(frame->data, frame->data + frame->size); + c.values[0] = frame->width; c.values[1] = frame->height; + c.values[2] = frame->timestamp; c.values[3] = frame->sequence; + c.values[6] = monotonic_ns(); + c.ready.notify_one(); + }, &capture); + fprintf(stderr,"RGB start result=%d streaming=%d\n",result,xr_camera_provider_is_streaming(camera)); + rgb_usb_state(fd,"after-start"); + if (result == 0) { + { + std::unique_lock lock(capture.mutex); + capture.ready.wait_for(lock, std::chrono::seconds(5), [&] { return capture.frames >= 10 && !capture.jpeg.empty(); }); + } + fprintf(stderr,"RGB stop result=%d\n",xr_camera_provider_stop(camera)); + } + xr_camera_provider_destroy(camera); + rgb_usb_state(fd,"after-destroy"); + capture.values[4] = result; + capture.values[5] = capture.frames; + env->SetLongArrayRegion(metadata, 0, 7, capture.values); + if (capture.jpeg.empty()) return nullptr; + auto bytes = env->NewByteArray(static_cast(capture.jpeg.size())); + if (bytes) env->SetByteArrayRegion(bytes, 0, static_cast(capture.jpeg.size()), + reinterpret_cast(capture.jpeg.data())); + return bytes; +} diff --git a/app/src/main/cpp/viture/stereo_frame_gate.h b/app/src/main/cpp/viture/stereo_frame_gate.h new file mode 100644 index 0000000000..ae5a8f5ff1 --- /dev/null +++ b/app/src/main/cpp/viture/stereo_frame_gate.h @@ -0,0 +1,29 @@ +#pragma once +#include +#include + +struct StereoFrameGate { + uint64_t received = 0, skipped = 0; + void SetRatePermille(int rate) { + if (rate != 500 && rate != 600 && rate != 800 && rate != 1000) rate = 500; + if (ratePermille_ != rate) phase_ = 1000-rate; + ratePermille_ = rate; + } + void SetHalfRate(bool enabled) { + SetRatePermille(enabled ? 500 : 1000); + } + bool Accept(double source) { + if (!std::isfinite(source) || source <= 0) return false; + ++received; + if (source <= lastSource_) phase_ = 1000-ratePermille_; + lastSource_ = source; + phase_ += ratePermille_; + const bool copy = phase_ >= 1000; + if (copy) phase_ -= 1000; + if (!copy) ++skipped; + return copy; + } +private: + int ratePermille_ = 1000, phase_ = 0; + double lastSource_ = 0; +}; diff --git a/app/src/main/cpp/viture/uvc_bridge.cpp b/app/src/main/cpp/viture/uvc_bridge.cpp new file mode 100644 index 0000000000..38bf9a1051 --- /dev/null +++ b/app/src/main/cpp/viture/uvc_bridge.cpp @@ -0,0 +1,134 @@ +#include +#include +#include +#include "mjpeg_payload.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { +struct UsbLog { + int saved; + bool hadLevel; + std::string level; + explicit UsbLog(int fd) : saved(dup(STDERR_FILENO)), hadLevel(getenv("LIBUSB_DEBUG") != nullptr), + level(hadLevel ? getenv("LIBUSB_DEBUG") : "") { + fflush(stderr); + if (saved >= 0) dup2(fd, STDERR_FILENO); + setenv("LIBUSB_DEBUG", "3", 1); + libusb_set_log_cb(nullptr, [](libusb_context*, libusb_log_level, const char* text) { + fputs(text, stderr); + }, LIBUSB_LOG_CB_GLOBAL); + } + ~UsbLog() { + libusb_set_log_cb(nullptr, nullptr, LIBUSB_LOG_CB_GLOBAL); + fflush(stderr); + if (saved >= 0) { dup2(saved, STDERR_FILENO); close(saved); } + if (hadLevel) setenv("LIBUSB_DEBUG", level.c_str(), 1); else unsetenv("LIBUSB_DEBUG"); + } +}; + +struct Capture { + std::mutex mutex; + std::condition_variable ready; + std::vector jpeg; + jlong values[14]{}; + bool accepting = true; +}; + +jlong monotonic_ns() { + timespec now{}; + clock_gettime(CLOCK_MONOTONIC, &now); + return now.tv_sec*1000000000LL+now.tv_nsec; +} + +void finish_observation(Capture& capture) { + std::lock_guard lock(capture.mutex); + if (!capture.accepting) return; + capture.accepting = false; + capture.values[12] = monotonic_ns(); + if (capture.values[6]) capture.values[13] = capture.values[12]-capture.values[6]; + capture.values[8] = std::max(capture.values[8],capture.values[13]); +} + +void frame_received(uvc_frame_t* frame, void* user) { + auto& capture = *static_cast(user); + std::lock_guard lock(capture.mutex); + if (!capture.accepting) return; + ++capture.values[5]; + const auto* bytes = frame ? static_cast(frame->data) : nullptr; + const size_t size = frame ? frame->data_bytes : 0; + const size_t jpegSize = frame && frame->frame_format == UVC_FRAME_FORMAT_MJPEG ? mjpeg_payload_size(bytes,size) : 0; + if (!jpegSize) { + ++capture.values[10]; + return; + } + const jlong time = monotonic_ns(); + capture.values[0]=frame->width; capture.values[1]=frame->height; capture.values[3]=frame->sequence; + if (!capture.values[7]) capture.values[7]=time; + if (capture.values[6]) capture.values[8]=std::max(capture.values[8],time-capture.values[6]); + capture.values[6]=time; + ++capture.values[9]; + capture.values[11]+=jpegSize; + capture.jpeg.assign(bytes,bytes+jpegSize); + capture.ready.notify_one(); +} +} + +extern "C" JNIEXPORT jbyteArray JNICALL +Java_com_droiddeck_launcher_glasses_UvcRgbDiagnostic_nativeSnapshot(JNIEnv* env, jobject, + jint fd, jint width, jint height, jint fps, jint durationMs, jlongArray metadata, jint logFd) { + if (fd<0 || logFd<0 || !metadata || env->GetArrayLength(metadata)!=14 || width<160 || width>1920 || + height<120 || height>1080 || fps<5 || fps>30 || durationMs<1000 || durationMs>30000) return nullptr; + UsbLog log(logFd); + Capture capture; + uvc_context_t* context=nullptr; + uvc_device_handle_t* camera=nullptr; + libusb_set_option(nullptr,LIBUSB_OPTION_NO_DEVICE_DISCOVERY); + int result=uvc_init(&context,nullptr); + fprintf(stderr,"UVC init=%d\n",result); + if (result==0) { + result=uvc_wrap(fd,context,&camera); + fprintf(stderr,"UVC wrap=%d\n",result); + } + if (result==0) { + uvc_print_diag(camera,stderr); + uvc_stream_ctrl_t control{}; + result=uvc_get_stream_ctrl_format_size(camera,&control,UVC_FRAME_FORMAT_MJPEG,width,height,fps); + fprintf(stderr,"UVC negotiate=%d requested=%dx%d@%d\n",result,width,height,fps); + if (result==0) { + uvc_print_stream_ctrl(&control,stderr); + result=uvc_start_streaming(camera,&control,frame_received,&capture,0); + fprintf(stderr,"UVC start=%d\n",result); + if (result==0) { + { + std::unique_lock lock(capture.mutex); + if (capture.ready.wait_for(lock,std::chrono::seconds(5),[&] { return !capture.jpeg.empty(); })) + capture.ready.wait_for(lock,std::chrono::milliseconds(durationMs),[] { return false; }); + } + finish_observation(capture); + uvc_stop_streaming(camera); + } + } + } + finish_observation(capture); + if (camera) uvc_close(camera); + if (context) uvc_exit(context); + capture.values[4]=result; + fprintf(stderr,"UVC result=%d callbacks=%lld complete=%lld invalid=%lld maxGapMs=%.3f tailMs=%.3f\n",result, + static_cast(capture.values[5]),static_cast(capture.values[9]), + static_cast(capture.values[10]),capture.values[8]/1e6,capture.values[13]/1e6); + env->SetLongArrayRegion(metadata,0,14,capture.values); + if (result!=0 || capture.jpeg.empty()) return nullptr; + auto bytes=env->NewByteArray(static_cast(capture.jpeg.size())); + if (bytes) env->SetByteArrayRegion(bytes,0,static_cast(capture.jpeg.size()), + reinterpret_cast(capture.jpeg.data())); + return bytes; +} diff --git a/app/src/main/cpp/waylandcomp/CMakeLists.txt b/app/src/main/cpp/waylandcomp/CMakeLists.txt index 98c5385ee9..47ab1c5522 100644 --- a/app/src/main/cpp/waylandcomp/CMakeLists.txt +++ b/app/src/main/cpp/waylandcomp/CMakeLists.txt @@ -3,6 +3,7 @@ add_library(droiddeckwayland SHARED src/vk_present.c src/effects_chain.c src/cardboard.c + src/spatialpose.c src/vk_loader.c src/sc_layer.c src/ahb_swapchain.c diff --git a/app/src/main/cpp/waylandcomp/src/cardboard.c b/app/src/main/cpp/waylandcomp/src/cardboard.c index 8031d61d72..fc09d2f030 100644 --- a/app/src/main/cpp/waylandcomp/src/cardboard.c +++ b/app/src/main/cpp/waylandcomp/src/cardboard.c @@ -28,22 +28,25 @@ static float clampf(float v, float lo, float hi) { return v < lo ? lo : v > hi ? void cardboard_clamp(struct cardboard_params *p) { p->enabled = p->enabled ? 1 : 0; - p->source = p->source == CARDBOARD_SOURCE_SBS ? CARDBOARD_SOURCE_SBS : CARDBOARD_SOURCE_SCREEN; + if (p->source < CARDBOARD_SOURCE_SCREEN || p->source > CARDBOARD_SOURCE_FLAT) p->source = CARDBOARD_SOURCE_SCREEN; p->ipd_m = clampf(p->ipd_m, 0.0f, 0.1f); p->screen_dist_m = clampf(p->screen_dist_m, 0.5f, 50.0f); p->screen_width_m = clampf(p->screen_width_m, 0.2f, 60.0f); p->k1 = clampf(p->k1, -1.0f, 2.0f); p->k2 = clampf(p->k2, -1.0f, 2.0f); - p->fov_deg = clampf(p->fov_deg, 30.0f, 140.0f); + // Optical vertical FOV on supported glasses can be as low as ~22 degrees. + p->fov_deg = clampf(p->fov_deg, 20.0f, 140.0f); p->lens_inset = clampf(p->lens_inset, -0.25f, 0.25f); p->chroma = clampf(p->chroma, 0.0f, 0.05f); + p->mono = p->mono ? 1 : 0; + p->display_hz = clampf(p->display_hz, 0.0f, 240.0f); } void cardboard_push_constants(const struct cardboard_params *p, const float pose[9], int src_w, int src_h, int out_w, int out_h, float out[24]) { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) out[r * 4 + c] = pose[r * 3 + c]; - out[3] = p->ipd_m * 0.5f; + out[3] = p->mono ? 0.0f : p->ipd_m * 0.5f; out[7] = p->screen_dist_m; out[11] = p->screen_width_m * 0.5f; out[12] = p->k1; @@ -54,13 +57,17 @@ void cardboard_push_constants(const struct cardboard_params *p, const float pose out[17] = (src_w > 0 && src_h > 0) ? (float)src_w / (float)src_h : 16.0f / 9.0f; if (p->source == CARDBOARD_SOURCE_SBS) out[17] *= 0.5f; out[18] = (float)p->source; - out[19] = (out_w > 0 && out_h > 0) ? ((float)out_w * 0.5f) / (float)out_h : 1.0f; - out[20] = out[21] = out[22] = out[23] = 0.0f; + out[19] = (out_w > 0 && out_h > 0) ? ((float)out_w * (p->mono ? 1.0f : 0.5f)) / (float)out_h : 1.0f; + out[20] = p->mono ? 1.0f : 0.0f; + out[21] = out[22] = out[23] = 0.0f; +} + +void cardboard_push_translation(const struct cardboard_params *p, const float position[3], float out[24]) { + for (int i = 0; i < 3; ++i) out[21+i] = p->source == CARDBOARD_SOURCE_SCREEN && isfinite(position[i]) ? position[i] : 0.0f; } #ifndef CARDBOARD_HOST_TEST - static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER; static struct cardboard_params g_set = { .enabled = 0, .source = CARDBOARD_SOURCE_SCREEN, .ipd_m = 0.064f, .screen_dist_m = 3.0f, @@ -68,6 +75,7 @@ static struct cardboard_params g_set = { static float g_pose[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1}; static volatile int g_changed = 1; +static float g_position[3]; static int g_live; static void shm_publish(int live); @@ -81,13 +89,22 @@ void vkp_cardboard_set(const struct cardboard_params *p) { shm_publish(g_live); pthread_mutex_unlock(&g_lock); if (was != c.enabled || c.enabled) - droiddeck_log("cardboard", "%s: %s, ipd %.0f mm, screen %.1f m wide at %.1f m, lens k1 %.2f k2 %.2f, fov %.0f, inset %.3f, chroma %.3f", - c.enabled ? "on" : "off", c.source == CARDBOARD_SOURCE_SBS ? "side-by-side source" : "virtual screen", - c.ipd_m * 1000.0f, c.screen_width_m, c.screen_dist_m, c.k1, c.k2, c.fov_deg, c.lens_inset, c.chroma); + droiddeck_log("cardboard", "%s: %s%s, ipd %.0f mm, screen %.1f m wide at %.1f m, lens k1 %.2f k2 %.2f, fov %.0f, inset %.3f, chroma %.3f", + c.enabled ? "on" : "off", c.source == CARDBOARD_SOURCE_SBS ? "side-by-side source" : + c.source == CARDBOARD_SOURCE_FLAT ? "flat image in both eyes" : "virtual screen", + c.mono ? " (one eye)" : "", c.ipd_m * 1000.0f, c.screen_width_m, c.screen_dist_m, c.k1, c.k2, c.fov_deg, c.lens_inset, c.chroma); } static struct droiddeck_headpose *g_shm; static int g_eye_w, g_eye_h; +static int g_render_height; + +void vkp_cardboard_set_render_height(int height) { + pthread_mutex_lock(&g_lock); + g_render_height = height > 0 ? height : 0; + shm_publish(g_live); + pthread_mutex_unlock(&g_lock); +} void vkp_cardboard_set_pose_file(const char *path) { pthread_mutex_lock(&g_lock); @@ -101,6 +118,7 @@ void vkp_cardboard_set_pose_file(const char *path) { g_shm->magic = DROIDDECK_HEADPOSE_MAGIC; g_shm->version = DROIDDECK_HEADPOSE_VERSION; memcpy(g_shm->rot, g_pose, sizeof(g_shm->rot)); + shm_publish(g_live); } } if (fd >= 0) close(fd); @@ -119,7 +137,10 @@ static void shm_publish(int live) { atomic_thread_fence(memory_order_release); memcpy(g_shm->rot, g_pose, sizeof(g_shm->rot)); g_shm->ipd_m = g_set.ipd_m; - g_shm->flags = (live ? DROIDDECK_HEADPOSE_LIVE : 0u) | (g_set.enabled ? DROIDDECK_HEADPOSE_ENABLED : 0u); + g_shm->flags = (live ? DROIDDECK_HEADPOSE_LIVE : 0u) | (g_set.enabled ? DROIDDECK_HEADPOSE_ENABLED : 0u) | + (g_set.mono ? DROIDDECK_HEADPOSE_MONO : 0u); + g_shm->display_hz = g_set.display_hz; + g_shm->render_height = (uint32_t)g_render_height; g_shm->time_ns = (int64_t)ts.tv_sec * 1000000000LL + ts.tv_nsec; g_shm->tan_half_fov = tanf(g_set.fov_deg * 0.5f * (float)M_PI / 180.0f); g_shm->eye_w = (uint32_t)(g_eye_w > 0 ? g_eye_w : 0); @@ -130,22 +151,31 @@ static void shm_publish(int live) { } -void vkp_cardboard_set_pose(const float m[9], int live) { +void vkp_cardboard_set_spatial_pose(const float m[9], const float position[3], int live) { pthread_mutex_lock(&g_lock); memcpy(g_pose, m, sizeof(g_pose)); + memcpy(g_position, position, sizeof(g_position)); g_live = live; if (g_set.enabled && g_set.source == CARDBOARD_SOURCE_SCREEN) g_changed = 1; shm_publish(live); pthread_mutex_unlock(&g_lock); } +void vkp_cardboard_set_pose(const float m[9], int live) { + const float zero[3] = {0}; + vkp_cardboard_set_spatial_pose(m, zero, live); +} + + static struct cardboard_params g_cur; static float g_cur_pose[9]; +static float g_cur_position[3]; static void snapshot(void) { pthread_mutex_lock(&g_lock); g_cur = g_set; memcpy(g_cur_pose, g_pose, sizeof(g_cur_pose)); + memcpy(g_cur_position, g_position, sizeof(g_cur_position)); pthread_mutex_unlock(&g_lock); } @@ -401,16 +431,18 @@ VkImage vkp_cardboard_run(VkCommandBuffer cmd, VkImage src, int src_w, int src_h if (!said) { said = 1; droiddeck_log("error", "cardboard: no descriptor for the frame; shown flat"); } return VK_NULL_HANDLE; } - if (g_eye_w != out_w / 2 || g_eye_h != out_h) { + snapshot(); + int eye_w = g_cur.mono ? out_w : out_w / 2; + if (g_eye_w != eye_w || g_eye_h != out_h) { pthread_mutex_lock(&g_lock); - g_eye_w = out_w / 2; + g_eye_w = eye_w; g_eye_h = out_h; shm_publish(g_live); pthread_mutex_unlock(&g_lock); } - snapshot(); struct { float ndc[4]; float rest[24]; } pc = {{-1.0f, -1.0f, 1.0f, 1.0f}, {0}}; cardboard_push_constants(&g_cur, g_cur_pose, src_w, src_h, out_w, out_h, pc.rest); + cardboard_push_translation(&g_cur, g_cur_position, pc.rest); VkRenderPassBeginInfo rpi = {.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, .renderPass = g_rp, .framebuffer = g_t.fb, .renderArea = {{0, 0}, {(uint32_t)out_w, (uint32_t)out_h}}}; diff --git a/app/src/main/cpp/waylandcomp/src/cardboard.frag b/app/src/main/cpp/waylandcomp/src/cardboard.frag index 4dbc67fc2c..33298f7b87 100644 --- a/app/src/main/cpp/waylandcomp/src/cardboard.frag +++ b/app/src/main/cpp/waylandcomp/src/cardboard.frag @@ -10,7 +10,7 @@ layout(push_constant) uniform PC { vec4 rot2; vec4 lens; vec4 view; - + vec4 extra; } pc; const vec3 BACKDROP = vec3(0.015, 0.015, 0.02); @@ -24,14 +24,21 @@ vec3 eyeSample(vec2 tan, float eye) { if (pc.view.z > 0.5) { float tanH = pc.lens.z; vec2 s = vec2(tan.x / (tanH * pc.view.w), tan.y / tanH) * 0.5 + 0.5; + if (pc.view.z > 1.5) { + vec2 fit = max(vec2(pc.view.w / pc.view.y, pc.view.y / pc.view.w), vec2(1.0)); + s = (s - 0.5) * fit + 0.5; + if (any(lessThan(s, vec2(0.0))) || any(greaterThan(s, vec2(1.0)))) return vec3(0.0); + return texture(Source, s).rgb; + } if (any(lessThan(s, vec2(0.0))) || any(greaterThan(s, vec2(1.0)))) return vec3(0.0); return texture(Source, vec2((s.x + eye) * 0.5, s.y)).rgb; } mat3 R = transpose(mat3(pc.rot0.xyz, pc.rot1.xyz, pc.rot2.xyz)); vec3 d = R * normalize(vec3(tan.x, -tan.y, -1.0)); - vec3 o = R * vec3((eye < 0.5 ? -1.0 : 1.0) * pc.rot0.w, 0.0, 0.0); + vec3 o = pc.extra.yzw + R * vec3((eye < 0.5 ? -1.0 : 1.0) * pc.rot0.w, 0.0, 0.0); if (d.z > -1e-4) return BACKDROP; float t = (-pc.rot1.w - o.z) / d.z; + if (t <= 0.0) return BACKDROP; vec3 hit = o + d * t; float halfW = pc.rot2.w, halfH = halfW / pc.view.y; vec2 s = vec2(hit.x / halfW, -hit.y / halfH) * 0.5 + 0.5; @@ -40,9 +47,10 @@ vec3 eyeSample(vec2 tan, float eye) { } void main() { - float eye = uv.x < 0.5 ? 0.0 : 1.0; - vec2 local = vec2(uv.x * 2.0 - eye, uv.y); - float cx = 0.5 + (eye < 0.5 ? pc.view.x : -pc.view.x); + bool mono = pc.extra.x > 0.5; + float eye = mono || uv.x < 0.5 ? 0.0 : 1.0; + vec2 local = mono ? uv : vec2(uv.x * 2.0 - eye, uv.y); + float cx = mono ? 0.5 : 0.5 + (eye < 0.5 ? pc.view.x : -pc.view.x); vec2 p = local - vec2(cx, 0.5); float tanH = pc.lens.z; vec2 t = vec2(p.x * pc.view.w, p.y) * 2.0 * tanH; diff --git a/app/src/main/cpp/waylandcomp/src/cardboard.h b/app/src/main/cpp/waylandcomp/src/cardboard.h index 3fd99e6b7d..88d5ea3ff7 100644 --- a/app/src/main/cpp/waylandcomp/src/cardboard.h +++ b/app/src/main/cpp/waylandcomp/src/cardboard.h @@ -3,7 +3,7 @@ #define VK_USE_PLATFORM_ANDROID_KHR #include -enum { CARDBOARD_SOURCE_SCREEN = 0, CARDBOARD_SOURCE_SBS = 1 }; +enum { CARDBOARD_SOURCE_SCREEN = 0, CARDBOARD_SOURCE_SBS = 1, CARDBOARD_SOURCE_FLAT = 2 }; struct cardboard_params { int enabled; @@ -15,11 +15,15 @@ struct cardboard_params { float fov_deg; float lens_inset; float chroma; + int mono; + float display_hz; }; void vkp_cardboard_set(const struct cardboard_params *p); void vkp_cardboard_set_pose(const float m[9], int live); +void vkp_cardboard_set_spatial_pose(const float m[9], const float position[3], int live); void vkp_cardboard_set_pose_file(const char *path); +void vkp_cardboard_set_render_height(int height); void vkp_cardboard_bind_device(VkDevice dev, const VkPhysicalDeviceMemoryProperties *memprops); int vkp_cardboard_active(void); @@ -30,5 +34,6 @@ VkImage vkp_cardboard_run(VkCommandBuffer cmd, VkImage src, int src_w, int src_h void cardboard_clamp(struct cardboard_params *p); void cardboard_push_constants(const struct cardboard_params *p, const float pose[9], int src_w, int src_h, int out_w, int out_h, float out[24]); +void cardboard_push_translation(const struct cardboard_params *p, const float position[3], float out[24]); #endif diff --git a/app/src/main/cpp/waylandcomp/src/cardboard_frag.h b/app/src/main/cpp/waylandcomp/src/cardboard_frag.h index 76f72467ad..f74676d6a9 100644 --- a/app/src/main/cpp/waylandcomp/src/cardboard_frag.h +++ b/app/src/main/cpp/waylandcomp/src/cardboard_frag.h @@ -1,8 +1,9 @@ + // 1115.1.0 #pragma once const uint32_t cardboard_frag_code[] = { - 0x07230203,0x00010000,0x0008000b,0x0000016d,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x07230203,0x00010000,0x0008000b,0x000001ba,0x00000000,0x00020011,0x00000001,0x0006000b, 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, - 0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x000000ee,0x00000165,0x00030010, + 0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x0000012d,0x000001b2,0x00030010, 0x00000004,0x00000007,0x00030003,0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d, 0x00000000,0x00070005,0x0000000d,0x69646e75,0x726f7473,0x66762874,0x31663b32,0x0000003b, 0x00030005,0x0000000b,0x00000074,0x00040005,0x0000000c,0x6c616373,0x00000065,0x00070005, @@ -11,255 +12,306 @@ const uint32_t cardboard_frag_code[] = { 0x0000001e,0x00004350,0x00040006,0x0000001e,0x00000000,0x0063646e,0x00050006,0x0000001e, 0x00000001,0x30746f72,0x00000000,0x00050006,0x0000001e,0x00000002,0x31746f72,0x00000000, 0x00050006,0x0000001e,0x00000003,0x32746f72,0x00000000,0x00050006,0x0000001e,0x00000004, - 0x736e656c,0x00000000,0x00050006,0x0000001e,0x00000005,0x77656976,0x00000000,0x00030005, - 0x00000020,0x00006370,0x00040005,0x0000003f,0x486e6174,0x00000000,0x00030005,0x00000042, - 0x00000073,0x00040005,0x00000068,0x72756f53,0x00006563,0x00030005,0x00000077,0x00000052, - 0x00030005,0x00000094,0x00000064,0x00030005,0x0000009f,0x0000006f,0x00030005,0x000000b3, - 0x00000074,0x00030005,0x000000bd,0x00746968,0x00040005,0x000000c3,0x666c6168,0x00000057, - 0x00040005,0x000000c6,0x666c6168,0x00000048,0x00030005,0x000000cb,0x00000073,0x00030005, - 0x000000ec,0x00657965,0x00030005,0x000000ee,0x00007675,0x00040005,0x000000f4,0x61636f6c, - 0x0000006c,0x00030005,0x000000fe,0x00007863,0x00030005,0x0000010c,0x00000070,0x00040005, - 0x00000111,0x486e6174,0x00000000,0x00030005,0x00000114,0x00000074,0x00030005,0x00000125, - 0x00000063,0x00040005,0x00000129,0x61726170,0x0000006d,0x00040005,0x0000012b,0x61726170, - 0x0000006d,0x00040005,0x0000012d,0x61726170,0x0000006d,0x00040005,0x0000012e,0x61726170, - 0x0000006d,0x00040005,0x00000133,0x61726170,0x0000006d,0x00040005,0x00000135,0x61726170, - 0x0000006d,0x00040005,0x00000137,0x61726170,0x0000006d,0x00040005,0x00000138,0x61726170, - 0x0000006d,0x00040005,0x00000140,0x61726170,0x0000006d,0x00040005,0x00000142,0x61726170, - 0x0000006d,0x00040005,0x00000144,0x61726170,0x0000006d,0x00040005,0x00000145,0x61726170, - 0x0000006d,0x00040005,0x0000014b,0x61726170,0x0000006d,0x00040005,0x0000014d,0x61726170, - 0x0000006d,0x00040005,0x0000014f,0x61726170,0x0000006d,0x00040005,0x00000150,0x61726170, - 0x0000006d,0x00030005,0x00000153,0x00000065,0x00040005,0x00000159,0x65646166,0x00000000, - 0x00050005,0x00000165,0x4374756f,0x726f6c6f,0x00000000,0x00030047,0x0000001e,0x00000002, - 0x00050048,0x0000001e,0x00000000,0x00000023,0x00000000,0x00050048,0x0000001e,0x00000001, - 0x00000023,0x00000010,0x00050048,0x0000001e,0x00000002,0x00000023,0x00000020,0x00050048, - 0x0000001e,0x00000003,0x00000023,0x00000030,0x00050048,0x0000001e,0x00000004,0x00000023, - 0x00000040,0x00050048,0x0000001e,0x00000005,0x00000023,0x00000050,0x00040047,0x00000068, - 0x00000021,0x00000000,0x00040047,0x00000068,0x00000022,0x00000000,0x00040047,0x000000ee, - 0x0000001e,0x00000000,0x00040047,0x00000165,0x0000001e,0x00000000,0x00020013,0x00000002, - 0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007, - 0x00000006,0x00000002,0x00040020,0x00000008,0x00000007,0x00000007,0x00040020,0x00000009, - 0x00000007,0x00000006,0x00050021,0x0000000a,0x00000007,0x00000008,0x00000009,0x00040017, - 0x0000000f,0x00000006,0x00000003,0x00050021,0x00000010,0x0000000f,0x00000008,0x00000009, - 0x0004002b,0x00000006,0x0000001c,0x3f800000,0x00040017,0x0000001d,0x00000006,0x00000004, - 0x0008001e,0x0000001e,0x0000001d,0x0000001d,0x0000001d,0x0000001d,0x0000001d,0x0000001d, - 0x00040020,0x0000001f,0x00000009,0x0000001e,0x0004003b,0x0000001f,0x00000020,0x00000009, - 0x00040015,0x00000021,0x00000020,0x00000001,0x0004002b,0x00000021,0x00000022,0x00000004, - 0x00040015,0x00000023,0x00000020,0x00000000,0x0004002b,0x00000023,0x00000024,0x00000000, - 0x00040020,0x00000025,0x00000009,0x00000006,0x0004002b,0x00000023,0x0000002b,0x00000001, - 0x0004002b,0x00000021,0x00000036,0x00000005,0x0004002b,0x00000023,0x00000037,0x00000002, - 0x0004002b,0x00000006,0x0000003a,0x3f000000,0x00020014,0x0000003b,0x0004002b,0x00000023, - 0x00000046,0x00000003,0x0004002b,0x00000006,0x00000054,0x00000000,0x0005002c,0x00000007, - 0x00000055,0x00000054,0x00000054,0x00040017,0x00000056,0x0000003b,0x00000002,0x0005002c, - 0x00000007,0x0000005d,0x0000001c,0x0000001c,0x0006002c,0x0000000f,0x00000063,0x00000054, - 0x00000054,0x00000054,0x00090019,0x00000065,0x00000006,0x00000001,0x00000000,0x00000000, - 0x00000000,0x00000001,0x00000000,0x0003001b,0x00000066,0x00000065,0x00040020,0x00000067, - 0x00000000,0x00000066,0x0004003b,0x00000067,0x00000068,0x00000000,0x00040018,0x00000075, - 0x0000000f,0x00000003,0x00040020,0x00000076,0x00000007,0x00000075,0x0004002b,0x00000021, - 0x00000078,0x00000001,0x00040020,0x00000079,0x00000009,0x0000001d,0x0004002b,0x00000021, - 0x0000007d,0x00000002,0x0004002b,0x00000021,0x00000081,0x00000003,0x00040020,0x00000093, - 0x00000007,0x0000000f,0x0004002b,0x00000006,0x0000009b,0xbf800000,0x0004002b,0x00000006, - 0x000000ab,0xb8d1b717,0x0004002b,0x00000006,0x000000af,0x3c75c28f,0x0004002b,0x00000006, - 0x000000b0,0x3ca3d70a,0x0006002c,0x0000000f,0x000000b1,0x000000af,0x000000af,0x000000b0, - 0x00040020,0x000000ed,0x00000001,0x00000007,0x0004003b,0x000000ed,0x000000ee,0x00000001, - 0x00040020,0x000000ef,0x00000001,0x00000006,0x0004002b,0x00000006,0x000000f7,0x40000000, - 0x0004002b,0x00000006,0x0000015a,0x3cf5c28f,0x00040020,0x00000164,0x00000003,0x0000001d, - 0x0004003b,0x00000164,0x00000165,0x00000003,0x00050036,0x00000002,0x00000004,0x00000000, - 0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000009,0x000000ec,0x00000007,0x0004003b, - 0x00000008,0x000000f4,0x00000007,0x0004003b,0x00000009,0x000000fe,0x00000007,0x0004003b, - 0x00000009,0x00000101,0x00000007,0x0004003b,0x00000008,0x0000010c,0x00000007,0x0004003b, - 0x00000009,0x00000111,0x00000007,0x0004003b,0x00000008,0x00000114,0x00000007,0x0004003b, - 0x00000093,0x00000125,0x00000007,0x0004003b,0x00000008,0x00000129,0x00000007,0x0004003b, - 0x00000009,0x0000012b,0x00000007,0x0004003b,0x00000008,0x0000012d,0x00000007,0x0004003b, - 0x00000009,0x0000012e,0x00000007,0x0004003b,0x00000008,0x00000133,0x00000007,0x0004003b, - 0x00000009,0x00000135,0x00000007,0x0004003b,0x00000008,0x00000137,0x00000007,0x0004003b, - 0x00000009,0x00000138,0x00000007,0x0004003b,0x00000008,0x00000140,0x00000007,0x0004003b, - 0x00000009,0x00000142,0x00000007,0x0004003b,0x00000008,0x00000144,0x00000007,0x0004003b, - 0x00000009,0x00000145,0x00000007,0x0004003b,0x00000008,0x0000014b,0x00000007,0x0004003b, - 0x00000009,0x0000014d,0x00000007,0x0004003b,0x00000008,0x0000014f,0x00000007,0x0004003b, - 0x00000009,0x00000150,0x00000007,0x0004003b,0x00000008,0x00000153,0x00000007,0x0004003b, - 0x00000009,0x00000159,0x00000007,0x00050041,0x000000ef,0x000000f0,0x000000ee,0x00000024, - 0x0004003d,0x00000006,0x000000f1,0x000000f0,0x000500b8,0x0000003b,0x000000f2,0x000000f1, - 0x0000003a,0x000600a9,0x00000006,0x000000f3,0x000000f2,0x00000054,0x0000001c,0x0003003e, - 0x000000ec,0x000000f3,0x00050041,0x000000ef,0x000000f5,0x000000ee,0x00000024,0x0004003d, - 0x00000006,0x000000f6,0x000000f5,0x00050085,0x00000006,0x000000f8,0x000000f6,0x000000f7, - 0x0004003d,0x00000006,0x000000f9,0x000000ec,0x00050083,0x00000006,0x000000fa,0x000000f8, - 0x000000f9,0x00050041,0x000000ef,0x000000fb,0x000000ee,0x0000002b,0x0004003d,0x00000006, - 0x000000fc,0x000000fb,0x00050050,0x00000007,0x000000fd,0x000000fa,0x000000fc,0x0003003e, - 0x000000f4,0x000000fd,0x0004003d,0x00000006,0x000000ff,0x000000ec,0x000500b8,0x0000003b, - 0x00000100,0x000000ff,0x0000003a,0x000300f7,0x00000103,0x00000000,0x000400fa,0x00000100, - 0x00000102,0x00000106,0x000200f8,0x00000102,0x00060041,0x00000025,0x00000104,0x00000020, - 0x00000036,0x00000024,0x0004003d,0x00000006,0x00000105,0x00000104,0x0003003e,0x00000101, - 0x00000105,0x000200f9,0x00000103,0x000200f8,0x00000106,0x00060041,0x00000025,0x00000107, - 0x00000020,0x00000036,0x00000024,0x0004003d,0x00000006,0x00000108,0x00000107,0x0004007f, - 0x00000006,0x00000109,0x00000108,0x0003003e,0x00000101,0x00000109,0x000200f9,0x00000103, - 0x000200f8,0x00000103,0x0004003d,0x00000006,0x0000010a,0x00000101,0x00050081,0x00000006, - 0x0000010b,0x0000003a,0x0000010a,0x0003003e,0x000000fe,0x0000010b,0x0004003d,0x00000007, - 0x0000010d,0x000000f4,0x0004003d,0x00000006,0x0000010e,0x000000fe,0x00050050,0x00000007, - 0x0000010f,0x0000010e,0x0000003a,0x00050083,0x00000007,0x00000110,0x0000010d,0x0000010f, - 0x0003003e,0x0000010c,0x00000110,0x00060041,0x00000025,0x00000112,0x00000020,0x00000022, - 0x00000037,0x0004003d,0x00000006,0x00000113,0x00000112,0x0003003e,0x00000111,0x00000113, - 0x00050041,0x00000009,0x00000115,0x0000010c,0x00000024,0x0004003d,0x00000006,0x00000116, - 0x00000115,0x00060041,0x00000025,0x00000117,0x00000020,0x00000036,0x00000046,0x0004003d, - 0x00000006,0x00000118,0x00000117,0x00050085,0x00000006,0x00000119,0x00000116,0x00000118, - 0x00050041,0x00000009,0x0000011a,0x0000010c,0x0000002b,0x0004003d,0x00000006,0x0000011b, - 0x0000011a,0x00050050,0x00000007,0x0000011c,0x00000119,0x0000011b,0x0005008e,0x00000007, - 0x0000011d,0x0000011c,0x000000f7,0x0004003d,0x00000006,0x0000011e,0x00000111,0x0005008e, - 0x00000007,0x0000011f,0x0000011d,0x0000011e,0x0003003e,0x00000114,0x0000011f,0x00060041, - 0x00000025,0x00000120,0x00000020,0x00000022,0x00000046,0x0004003d,0x00000006,0x00000121, - 0x00000120,0x000500ba,0x0000003b,0x00000122,0x00000121,0x00000054,0x000300f7,0x00000124, - 0x00000000,0x000400fa,0x00000122,0x00000123,0x0000014a,0x000200f8,0x00000123,0x00060041, - 0x00000025,0x00000126,0x00000020,0x00000022,0x00000046,0x0004003d,0x00000006,0x00000127, - 0x00000126,0x00050083,0x00000006,0x00000128,0x0000001c,0x00000127,0x0004003d,0x00000007, - 0x0000012a,0x00000114,0x0003003e,0x00000129,0x0000012a,0x0003003e,0x0000012b,0x00000128, - 0x00060039,0x00000007,0x0000012c,0x0000000d,0x00000129,0x0000012b,0x0003003e,0x0000012d, - 0x0000012c,0x0004003d,0x00000006,0x0000012f,0x000000ec,0x0003003e,0x0000012e,0x0000012f, - 0x00060039,0x0000000f,0x00000130,0x00000013,0x0000012d,0x0000012e,0x00050051,0x00000006, - 0x00000131,0x00000130,0x00000000,0x00050041,0x00000009,0x00000132,0x00000125,0x00000024, - 0x0003003e,0x00000132,0x00000131,0x0004003d,0x00000007,0x00000134,0x00000114,0x0003003e, - 0x00000133,0x00000134,0x0003003e,0x00000135,0x0000001c,0x00060039,0x00000007,0x00000136, - 0x0000000d,0x00000133,0x00000135,0x0003003e,0x00000137,0x00000136,0x0004003d,0x00000006, - 0x00000139,0x000000ec,0x0003003e,0x00000138,0x00000139,0x00060039,0x0000000f,0x0000013a, - 0x00000013,0x00000137,0x00000138,0x00050051,0x00000006,0x0000013b,0x0000013a,0x00000001, - 0x00050041,0x00000009,0x0000013c,0x00000125,0x0000002b,0x0003003e,0x0000013c,0x0000013b, - 0x00060041,0x00000025,0x0000013d,0x00000020,0x00000022,0x00000046,0x0004003d,0x00000006, - 0x0000013e,0x0000013d,0x00050081,0x00000006,0x0000013f,0x0000001c,0x0000013e,0x0004003d, - 0x00000007,0x00000141,0x00000114,0x0003003e,0x00000140,0x00000141,0x0003003e,0x00000142, - 0x0000013f,0x00060039,0x00000007,0x00000143,0x0000000d,0x00000140,0x00000142,0x0003003e, - 0x00000144,0x00000143,0x0004003d,0x00000006,0x00000146,0x000000ec,0x0003003e,0x00000145, - 0x00000146,0x00060039,0x0000000f,0x00000147,0x00000013,0x00000144,0x00000145,0x00050051, - 0x00000006,0x00000148,0x00000147,0x00000002,0x00050041,0x00000009,0x00000149,0x00000125, - 0x00000037,0x0003003e,0x00000149,0x00000148,0x000200f9,0x00000124,0x000200f8,0x0000014a, - 0x0004003d,0x00000007,0x0000014c,0x00000114,0x0003003e,0x0000014b,0x0000014c,0x0003003e, - 0x0000014d,0x0000001c,0x00060039,0x00000007,0x0000014e,0x0000000d,0x0000014b,0x0000014d, - 0x0003003e,0x0000014f,0x0000014e,0x0004003d,0x00000006,0x00000151,0x000000ec,0x0003003e, - 0x00000150,0x00000151,0x00060039,0x0000000f,0x00000152,0x00000013,0x0000014f,0x00000150, - 0x0003003e,0x00000125,0x00000152,0x000200f9,0x00000124,0x000200f8,0x00000124,0x0004003d, - 0x00000007,0x00000154,0x000000f4,0x0004003d,0x00000007,0x00000155,0x000000f4,0x00050050, - 0x00000007,0x00000156,0x0000001c,0x0000001c,0x00050083,0x00000007,0x00000157,0x00000156, - 0x00000155,0x0007000c,0x00000007,0x00000158,0x00000001,0x00000025,0x00000154,0x00000157, - 0x0003003e,0x00000153,0x00000158,0x00050041,0x00000009,0x0000015b,0x00000153,0x00000024, - 0x0004003d,0x00000006,0x0000015c,0x0000015b,0x00060041,0x00000025,0x0000015d,0x00000020, - 0x00000036,0x00000046,0x0004003d,0x00000006,0x0000015e,0x0000015d,0x00050085,0x00000006, - 0x0000015f,0x0000015c,0x0000015e,0x00050041,0x00000009,0x00000160,0x00000153,0x0000002b, - 0x0004003d,0x00000006,0x00000161,0x00000160,0x0007000c,0x00000006,0x00000162,0x00000001, - 0x00000025,0x0000015f,0x00000161,0x0008000c,0x00000006,0x00000163,0x00000001,0x00000031, - 0x00000054,0x0000015a,0x00000162,0x0003003e,0x00000159,0x00000163,0x0004003d,0x0000000f, - 0x00000166,0x00000125,0x0004003d,0x00000006,0x00000167,0x00000159,0x0005008e,0x0000000f, - 0x00000168,0x00000166,0x00000167,0x00050051,0x00000006,0x00000169,0x00000168,0x00000000, - 0x00050051,0x00000006,0x0000016a,0x00000168,0x00000001,0x00050051,0x00000006,0x0000016b, - 0x00000168,0x00000002,0x00070050,0x0000001d,0x0000016c,0x00000169,0x0000016a,0x0000016b, - 0x0000001c,0x0003003e,0x00000165,0x0000016c,0x000100fd,0x00010038,0x00050036,0x00000007, - 0x0000000d,0x00000000,0x0000000a,0x00030037,0x00000008,0x0000000b,0x00030037,0x00000009, - 0x0000000c,0x000200f8,0x0000000e,0x0004003b,0x00000009,0x00000015,0x00000007,0x0004003d, - 0x00000007,0x00000016,0x0000000b,0x0004003d,0x00000007,0x00000017,0x0000000b,0x00050094, - 0x00000006,0x00000018,0x00000016,0x00000017,0x0003003e,0x00000015,0x00000018,0x0004003d, - 0x00000007,0x00000019,0x0000000b,0x0004003d,0x00000006,0x0000001a,0x0000000c,0x0005008e, - 0x00000007,0x0000001b,0x00000019,0x0000001a,0x00060041,0x00000025,0x00000026,0x00000020, - 0x00000022,0x00000024,0x0004003d,0x00000006,0x00000027,0x00000026,0x0004003d,0x00000006, - 0x00000028,0x00000015,0x00050085,0x00000006,0x00000029,0x00000027,0x00000028,0x00050081, - 0x00000006,0x0000002a,0x0000001c,0x00000029,0x00060041,0x00000025,0x0000002c,0x00000020, - 0x00000022,0x0000002b,0x0004003d,0x00000006,0x0000002d,0x0000002c,0x0004003d,0x00000006, - 0x0000002e,0x00000015,0x00050085,0x00000006,0x0000002f,0x0000002d,0x0000002e,0x0004003d, - 0x00000006,0x00000030,0x00000015,0x00050085,0x00000006,0x00000031,0x0000002f,0x00000030, - 0x00050081,0x00000006,0x00000032,0x0000002a,0x00000031,0x0005008e,0x00000007,0x00000033, - 0x0000001b,0x00000032,0x000200fe,0x00000033,0x00010038,0x00050036,0x0000000f,0x00000013, - 0x00000000,0x00000010,0x00030037,0x00000008,0x00000011,0x00030037,0x00000009,0x00000012, - 0x000200f8,0x00000014,0x0004003b,0x00000009,0x0000003f,0x00000007,0x0004003b,0x00000008, - 0x00000042,0x00000007,0x0004003b,0x00000076,0x00000077,0x00000007,0x0004003b,0x00000093, - 0x00000094,0x00000007,0x0004003b,0x00000093,0x0000009f,0x00000007,0x0004003b,0x00000009, - 0x000000b3,0x00000007,0x0004003b,0x00000093,0x000000bd,0x00000007,0x0004003b,0x00000009, - 0x000000c3,0x00000007,0x0004003b,0x00000009,0x000000c6,0x00000007,0x0004003b,0x00000008, - 0x000000cb,0x00000007,0x00060041,0x00000025,0x00000038,0x00000020,0x00000036,0x00000037, - 0x0004003d,0x00000006,0x00000039,0x00000038,0x000500ba,0x0000003b,0x0000003c,0x00000039, - 0x0000003a,0x000300f7,0x0000003e,0x00000000,0x000400fa,0x0000003c,0x0000003d,0x0000003e, - 0x000200f8,0x0000003d,0x00060041,0x00000025,0x00000040,0x00000020,0x00000022,0x00000037, - 0x0004003d,0x00000006,0x00000041,0x00000040,0x0003003e,0x0000003f,0x00000041,0x00050041, - 0x00000009,0x00000043,0x00000011,0x00000024,0x0004003d,0x00000006,0x00000044,0x00000043, - 0x0004003d,0x00000006,0x00000045,0x0000003f,0x00060041,0x00000025,0x00000047,0x00000020, - 0x00000036,0x00000046,0x0004003d,0x00000006,0x00000048,0x00000047,0x00050085,0x00000006, - 0x00000049,0x00000045,0x00000048,0x00050088,0x00000006,0x0000004a,0x00000044,0x00000049, - 0x00050041,0x00000009,0x0000004b,0x00000011,0x0000002b,0x0004003d,0x00000006,0x0000004c, - 0x0000004b,0x0004003d,0x00000006,0x0000004d,0x0000003f,0x00050088,0x00000006,0x0000004e, - 0x0000004c,0x0000004d,0x00050050,0x00000007,0x0000004f,0x0000004a,0x0000004e,0x0005008e, - 0x00000007,0x00000050,0x0000004f,0x0000003a,0x00050050,0x00000007,0x00000051,0x0000003a, - 0x0000003a,0x00050081,0x00000007,0x00000052,0x00000050,0x00000051,0x0003003e,0x00000042, - 0x00000052,0x0004003d,0x00000007,0x00000053,0x00000042,0x000500b8,0x00000056,0x00000057, - 0x00000053,0x00000055,0x0004009a,0x0000003b,0x00000058,0x00000057,0x000400a8,0x0000003b, - 0x00000059,0x00000058,0x000300f7,0x0000005b,0x00000000,0x000400fa,0x00000059,0x0000005a, - 0x0000005b,0x000200f8,0x0000005a,0x0004003d,0x00000007,0x0000005c,0x00000042,0x000500ba, - 0x00000056,0x0000005e,0x0000005c,0x0000005d,0x0004009a,0x0000003b,0x0000005f,0x0000005e, - 0x000200f9,0x0000005b,0x000200f8,0x0000005b,0x000700f5,0x0000003b,0x00000060,0x00000058, - 0x0000003d,0x0000005f,0x0000005a,0x000300f7,0x00000062,0x00000000,0x000400fa,0x00000060, - 0x00000061,0x00000062,0x000200f8,0x00000061,0x000200fe,0x00000063,0x000200f8,0x00000062, - 0x0004003d,0x00000066,0x00000069,0x00000068,0x00050041,0x00000009,0x0000006a,0x00000042, - 0x00000024,0x0004003d,0x00000006,0x0000006b,0x0000006a,0x0004003d,0x00000006,0x0000006c, - 0x00000012,0x00050081,0x00000006,0x0000006d,0x0000006b,0x0000006c,0x00050085,0x00000006, - 0x0000006e,0x0000006d,0x0000003a,0x00050041,0x00000009,0x0000006f,0x00000042,0x0000002b, - 0x0004003d,0x00000006,0x00000070,0x0000006f,0x00050050,0x00000007,0x00000071,0x0000006e, - 0x00000070,0x00050057,0x0000001d,0x00000072,0x00000069,0x00000071,0x0008004f,0x0000000f, - 0x00000073,0x00000072,0x00000072,0x00000000,0x00000001,0x00000002,0x000200fe,0x00000073, - 0x000200f8,0x0000003e,0x00050041,0x00000079,0x0000007a,0x00000020,0x00000078,0x0004003d, - 0x0000001d,0x0000007b,0x0000007a,0x0008004f,0x0000000f,0x0000007c,0x0000007b,0x0000007b, - 0x00000000,0x00000001,0x00000002,0x00050041,0x00000079,0x0000007e,0x00000020,0x0000007d, - 0x0004003d,0x0000001d,0x0000007f,0x0000007e,0x0008004f,0x0000000f,0x00000080,0x0000007f, - 0x0000007f,0x00000000,0x00000001,0x00000002,0x00050041,0x00000079,0x00000082,0x00000020, - 0x00000081,0x0004003d,0x0000001d,0x00000083,0x00000082,0x0008004f,0x0000000f,0x00000084, - 0x00000083,0x00000083,0x00000000,0x00000001,0x00000002,0x00050051,0x00000006,0x00000085, - 0x0000007c,0x00000000,0x00050051,0x00000006,0x00000086,0x0000007c,0x00000001,0x00050051, - 0x00000006,0x00000087,0x0000007c,0x00000002,0x00050051,0x00000006,0x00000088,0x00000080, - 0x00000000,0x00050051,0x00000006,0x00000089,0x00000080,0x00000001,0x00050051,0x00000006, - 0x0000008a,0x00000080,0x00000002,0x00050051,0x00000006,0x0000008b,0x00000084,0x00000000, - 0x00050051,0x00000006,0x0000008c,0x00000084,0x00000001,0x00050051,0x00000006,0x0000008d, - 0x00000084,0x00000002,0x00060050,0x0000000f,0x0000008e,0x00000085,0x00000086,0x00000087, - 0x00060050,0x0000000f,0x0000008f,0x00000088,0x00000089,0x0000008a,0x00060050,0x0000000f, - 0x00000090,0x0000008b,0x0000008c,0x0000008d,0x00060050,0x00000075,0x00000091,0x0000008e, - 0x0000008f,0x00000090,0x00040054,0x00000075,0x00000092,0x00000091,0x0003003e,0x00000077, - 0x00000092,0x0004003d,0x00000075,0x00000095,0x00000077,0x00050041,0x00000009,0x00000096, - 0x00000011,0x00000024,0x0004003d,0x00000006,0x00000097,0x00000096,0x00050041,0x00000009, - 0x00000098,0x00000011,0x0000002b,0x0004003d,0x00000006,0x00000099,0x00000098,0x0004007f, - 0x00000006,0x0000009a,0x00000099,0x00060050,0x0000000f,0x0000009c,0x00000097,0x0000009a, - 0x0000009b,0x0006000c,0x0000000f,0x0000009d,0x00000001,0x00000045,0x0000009c,0x00050091, - 0x0000000f,0x0000009e,0x00000095,0x0000009d,0x0003003e,0x00000094,0x0000009e,0x0004003d, - 0x00000075,0x000000a0,0x00000077,0x0004003d,0x00000006,0x000000a1,0x00000012,0x000500b8, - 0x0000003b,0x000000a2,0x000000a1,0x0000003a,0x000600a9,0x00000006,0x000000a3,0x000000a2, - 0x0000009b,0x0000001c,0x00060041,0x00000025,0x000000a4,0x00000020,0x00000078,0x00000046, - 0x0004003d,0x00000006,0x000000a5,0x000000a4,0x00050085,0x00000006,0x000000a6,0x000000a3, - 0x000000a5,0x00060050,0x0000000f,0x000000a7,0x000000a6,0x00000054,0x00000054,0x00050091, - 0x0000000f,0x000000a8,0x000000a0,0x000000a7,0x0003003e,0x0000009f,0x000000a8,0x00050041, - 0x00000009,0x000000a9,0x00000094,0x00000037,0x0004003d,0x00000006,0x000000aa,0x000000a9, - 0x000500ba,0x0000003b,0x000000ac,0x000000aa,0x000000ab,0x000300f7,0x000000ae,0x00000000, - 0x000400fa,0x000000ac,0x000000ad,0x000000ae,0x000200f8,0x000000ad,0x000200fe,0x000000b1, - 0x000200f8,0x000000ae,0x00060041,0x00000025,0x000000b4,0x00000020,0x0000007d,0x00000046, - 0x0004003d,0x00000006,0x000000b5,0x000000b4,0x0004007f,0x00000006,0x000000b6,0x000000b5, - 0x00050041,0x00000009,0x000000b7,0x0000009f,0x00000037,0x0004003d,0x00000006,0x000000b8, - 0x000000b7,0x00050083,0x00000006,0x000000b9,0x000000b6,0x000000b8,0x00050041,0x00000009, - 0x000000ba,0x00000094,0x00000037,0x0004003d,0x00000006,0x000000bb,0x000000ba,0x00050088, - 0x00000006,0x000000bc,0x000000b9,0x000000bb,0x0003003e,0x000000b3,0x000000bc,0x0004003d, - 0x0000000f,0x000000be,0x0000009f,0x0004003d,0x0000000f,0x000000bf,0x00000094,0x0004003d, - 0x00000006,0x000000c0,0x000000b3,0x0005008e,0x0000000f,0x000000c1,0x000000bf,0x000000c0, - 0x00050081,0x0000000f,0x000000c2,0x000000be,0x000000c1,0x0003003e,0x000000bd,0x000000c2, - 0x00060041,0x00000025,0x000000c4,0x00000020,0x00000081,0x00000046,0x0004003d,0x00000006, - 0x000000c5,0x000000c4,0x0003003e,0x000000c3,0x000000c5,0x0004003d,0x00000006,0x000000c7, - 0x000000c3,0x00060041,0x00000025,0x000000c8,0x00000020,0x00000036,0x0000002b,0x0004003d, - 0x00000006,0x000000c9,0x000000c8,0x00050088,0x00000006,0x000000ca,0x000000c7,0x000000c9, - 0x0003003e,0x000000c6,0x000000ca,0x00050041,0x00000009,0x000000cc,0x000000bd,0x00000024, - 0x0004003d,0x00000006,0x000000cd,0x000000cc,0x0004003d,0x00000006,0x000000ce,0x000000c3, - 0x00050088,0x00000006,0x000000cf,0x000000cd,0x000000ce,0x00050041,0x00000009,0x000000d0, - 0x000000bd,0x0000002b,0x0004003d,0x00000006,0x000000d1,0x000000d0,0x0004007f,0x00000006, - 0x000000d2,0x000000d1,0x0004003d,0x00000006,0x000000d3,0x000000c6,0x00050088,0x00000006, - 0x000000d4,0x000000d2,0x000000d3,0x00050050,0x00000007,0x000000d5,0x000000cf,0x000000d4, - 0x0005008e,0x00000007,0x000000d6,0x000000d5,0x0000003a,0x00050050,0x00000007,0x000000d7, - 0x0000003a,0x0000003a,0x00050081,0x00000007,0x000000d8,0x000000d6,0x000000d7,0x0003003e, - 0x000000cb,0x000000d8,0x0004003d,0x00000007,0x000000d9,0x000000cb,0x000500b8,0x00000056, - 0x000000da,0x000000d9,0x00000055,0x0004009a,0x0000003b,0x000000db,0x000000da,0x000400a8, - 0x0000003b,0x000000dc,0x000000db,0x000300f7,0x000000de,0x00000000,0x000400fa,0x000000dc, - 0x000000dd,0x000000de,0x000200f8,0x000000dd,0x0004003d,0x00000007,0x000000df,0x000000cb, - 0x000500ba,0x00000056,0x000000e0,0x000000df,0x0000005d,0x0004009a,0x0000003b,0x000000e1, - 0x000000e0,0x000200f9,0x000000de,0x000200f8,0x000000de,0x000700f5,0x0000003b,0x000000e2, - 0x000000db,0x000000ae,0x000000e1,0x000000dd,0x000300f7,0x000000e4,0x00000000,0x000400fa, - 0x000000e2,0x000000e3,0x000000e4,0x000200f8,0x000000e3,0x000200fe,0x000000b1,0x000200f8, - 0x000000e4,0x0004003d,0x00000066,0x000000e6,0x00000068,0x0004003d,0x00000007,0x000000e7, - 0x000000cb,0x00050057,0x0000001d,0x000000e8,0x000000e6,0x000000e7,0x0008004f,0x0000000f, - 0x000000e9,0x000000e8,0x000000e8,0x00000000,0x00000001,0x00000002,0x000200fe,0x000000e9, - 0x00010038 + 0x736e656c,0x00000000,0x00050006,0x0000001e,0x00000005,0x77656976,0x00000000,0x00050006, + 0x0000001e,0x00000006,0x72747865,0x00000061,0x00030005,0x00000020,0x00006370,0x00040005, + 0x0000003f,0x486e6174,0x00000000,0x00030005,0x00000042,0x00000073,0x00030005,0x00000059, + 0x00746966,0x00040005,0x00000082,0x72756f53,0x00006563,0x00030005,0x000000a3,0x00000052, + 0x00030005,0x000000c0,0x00000064,0x00030005,0x000000cb,0x0000006f,0x00030005,0x000000e4, + 0x00000074,0x00030005,0x000000f3,0x00746968,0x00040005,0x000000f9,0x666c6168,0x00000057, + 0x00040005,0x000000fc,0x666c6168,0x00000048,0x00030005,0x00000101,0x00000073,0x00040005, + 0x00000123,0x6f6e6f6d,0x00000000,0x00030005,0x00000127,0x00657965,0x00030005,0x0000012d, + 0x00007675,0x00040005,0x00000134,0x61636f6c,0x0000006c,0x00030005,0x00000145,0x00007863, + 0x00030005,0x00000159,0x00000070,0x00040005,0x0000015e,0x486e6174,0x00000000,0x00030005, + 0x00000161,0x00000074,0x00030005,0x00000172,0x00000063,0x00040005,0x00000176,0x61726170, + 0x0000006d,0x00040005,0x00000178,0x61726170,0x0000006d,0x00040005,0x0000017a,0x61726170, + 0x0000006d,0x00040005,0x0000017b,0x61726170,0x0000006d,0x00040005,0x00000180,0x61726170, + 0x0000006d,0x00040005,0x00000182,0x61726170,0x0000006d,0x00040005,0x00000184,0x61726170, + 0x0000006d,0x00040005,0x00000185,0x61726170,0x0000006d,0x00040005,0x0000018d,0x61726170, + 0x0000006d,0x00040005,0x0000018f,0x61726170,0x0000006d,0x00040005,0x00000191,0x61726170, + 0x0000006d,0x00040005,0x00000192,0x61726170,0x0000006d,0x00040005,0x00000198,0x61726170, + 0x0000006d,0x00040005,0x0000019a,0x61726170,0x0000006d,0x00040005,0x0000019c,0x61726170, + 0x0000006d,0x00040005,0x0000019d,0x61726170,0x0000006d,0x00030005,0x000001a0,0x00000065, + 0x00040005,0x000001a6,0x65646166,0x00000000,0x00050005,0x000001b2,0x4374756f,0x726f6c6f, + 0x00000000,0x00030047,0x0000001e,0x00000002,0x00050048,0x0000001e,0x00000000,0x00000023, + 0x00000000,0x00050048,0x0000001e,0x00000001,0x00000023,0x00000010,0x00050048,0x0000001e, + 0x00000002,0x00000023,0x00000020,0x00050048,0x0000001e,0x00000003,0x00000023,0x00000030, + 0x00050048,0x0000001e,0x00000004,0x00000023,0x00000040,0x00050048,0x0000001e,0x00000005, + 0x00000023,0x00000050,0x00050048,0x0000001e,0x00000006,0x00000023,0x00000060,0x00040047, + 0x00000082,0x00000021,0x00000000,0x00040047,0x00000082,0x00000022,0x00000000,0x00040047, + 0x0000012d,0x0000001e,0x00000000,0x00040047,0x000001b2,0x0000001e,0x00000000,0x00020013, + 0x00000002,0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017, + 0x00000007,0x00000006,0x00000002,0x00040020,0x00000008,0x00000007,0x00000007,0x00040020, + 0x00000009,0x00000007,0x00000006,0x00050021,0x0000000a,0x00000007,0x00000008,0x00000009, + 0x00040017,0x0000000f,0x00000006,0x00000003,0x00050021,0x00000010,0x0000000f,0x00000008, + 0x00000009,0x0004002b,0x00000006,0x0000001c,0x3f800000,0x00040017,0x0000001d,0x00000006, + 0x00000004,0x0009001e,0x0000001e,0x0000001d,0x0000001d,0x0000001d,0x0000001d,0x0000001d, + 0x0000001d,0x0000001d,0x00040020,0x0000001f,0x00000009,0x0000001e,0x0004003b,0x0000001f, + 0x00000020,0x00000009,0x00040015,0x00000021,0x00000020,0x00000001,0x0004002b,0x00000021, + 0x00000022,0x00000004,0x00040015,0x00000023,0x00000020,0x00000000,0x0004002b,0x00000023, + 0x00000024,0x00000000,0x00040020,0x00000025,0x00000009,0x00000006,0x0004002b,0x00000023, + 0x0000002b,0x00000001,0x0004002b,0x00000021,0x00000036,0x00000005,0x0004002b,0x00000023, + 0x00000037,0x00000002,0x0004002b,0x00000006,0x0000003a,0x3f000000,0x00020014,0x0000003b, + 0x0004002b,0x00000023,0x00000046,0x00000003,0x0004002b,0x00000006,0x00000055,0x3fc00000, + 0x0005002c,0x00000007,0x00000065,0x0000001c,0x0000001c,0x0004002b,0x00000006,0x0000006f, + 0x00000000,0x0005002c,0x00000007,0x00000070,0x0000006f,0x0000006f,0x00040017,0x00000071, + 0x0000003b,0x00000002,0x0006002c,0x0000000f,0x0000007d,0x0000006f,0x0000006f,0x0000006f, + 0x00090019,0x0000007f,0x00000006,0x00000001,0x00000000,0x00000000,0x00000000,0x00000001, + 0x00000000,0x0003001b,0x00000080,0x0000007f,0x00040020,0x00000081,0x00000000,0x00000080, + 0x0004003b,0x00000081,0x00000082,0x00000000,0x00040018,0x000000a1,0x0000000f,0x00000003, + 0x00040020,0x000000a2,0x00000007,0x000000a1,0x0004002b,0x00000021,0x000000a4,0x00000001, + 0x00040020,0x000000a5,0x00000009,0x0000001d,0x0004002b,0x00000021,0x000000a9,0x00000002, + 0x0004002b,0x00000021,0x000000ad,0x00000003,0x00040020,0x000000bf,0x00000007,0x0000000f, + 0x0004002b,0x00000006,0x000000c7,0xbf800000,0x0004002b,0x00000021,0x000000cc,0x00000006, + 0x0004002b,0x00000006,0x000000dc,0xb8d1b717,0x0004002b,0x00000006,0x000000e0,0x3c75c28f, + 0x0004002b,0x00000006,0x000000e1,0x3ca3d70a,0x0006002c,0x0000000f,0x000000e2,0x000000e0, + 0x000000e0,0x000000e1,0x00040020,0x00000122,0x00000007,0x0000003b,0x00040020,0x0000012c, + 0x00000001,0x00000007,0x0004003b,0x0000012c,0x0000012d,0x00000001,0x00040020,0x0000012e, + 0x00000001,0x00000006,0x0004002b,0x00000006,0x0000013d,0x40000000,0x0004002b,0x00000006, + 0x000001a7,0x3cf5c28f,0x00040020,0x000001b1,0x00000003,0x0000001d,0x0004003b,0x000001b1, + 0x000001b2,0x00000003,0x00050036,0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8, + 0x00000005,0x0004003b,0x00000122,0x00000123,0x00000007,0x0004003b,0x00000009,0x00000127, + 0x00000007,0x0004003b,0x00000008,0x00000134,0x00000007,0x0004003b,0x00000008,0x00000136, + 0x00000007,0x0004003b,0x00000009,0x00000145,0x00000007,0x0004003b,0x00000009,0x00000147, + 0x00000007,0x0004003b,0x00000009,0x0000014d,0x00000007,0x0004003b,0x00000008,0x00000159, + 0x00000007,0x0004003b,0x00000009,0x0000015e,0x00000007,0x0004003b,0x00000008,0x00000161, + 0x00000007,0x0004003b,0x000000bf,0x00000172,0x00000007,0x0004003b,0x00000008,0x00000176, + 0x00000007,0x0004003b,0x00000009,0x00000178,0x00000007,0x0004003b,0x00000008,0x0000017a, + 0x00000007,0x0004003b,0x00000009,0x0000017b,0x00000007,0x0004003b,0x00000008,0x00000180, + 0x00000007,0x0004003b,0x00000009,0x00000182,0x00000007,0x0004003b,0x00000008,0x00000184, + 0x00000007,0x0004003b,0x00000009,0x00000185,0x00000007,0x0004003b,0x00000008,0x0000018d, + 0x00000007,0x0004003b,0x00000009,0x0000018f,0x00000007,0x0004003b,0x00000008,0x00000191, + 0x00000007,0x0004003b,0x00000009,0x00000192,0x00000007,0x0004003b,0x00000008,0x00000198, + 0x00000007,0x0004003b,0x00000009,0x0000019a,0x00000007,0x0004003b,0x00000008,0x0000019c, + 0x00000007,0x0004003b,0x00000009,0x0000019d,0x00000007,0x0004003b,0x00000008,0x000001a0, + 0x00000007,0x0004003b,0x00000009,0x000001a6,0x00000007,0x00060041,0x00000025,0x00000124, + 0x00000020,0x000000cc,0x00000024,0x0004003d,0x00000006,0x00000125,0x00000124,0x000500ba, + 0x0000003b,0x00000126,0x00000125,0x0000003a,0x0003003e,0x00000123,0x00000126,0x0004003d, + 0x0000003b,0x00000128,0x00000123,0x000400a8,0x0000003b,0x00000129,0x00000128,0x000300f7, + 0x0000012b,0x00000000,0x000400fa,0x00000129,0x0000012a,0x0000012b,0x000200f8,0x0000012a, + 0x00050041,0x0000012e,0x0000012f,0x0000012d,0x00000024,0x0004003d,0x00000006,0x00000130, + 0x0000012f,0x000500b8,0x0000003b,0x00000131,0x00000130,0x0000003a,0x000200f9,0x0000012b, + 0x000200f8,0x0000012b,0x000700f5,0x0000003b,0x00000132,0x00000128,0x00000005,0x00000131, + 0x0000012a,0x000600a9,0x00000006,0x00000133,0x00000132,0x0000006f,0x0000001c,0x0003003e, + 0x00000127,0x00000133,0x0004003d,0x0000003b,0x00000135,0x00000123,0x000300f7,0x00000138, + 0x00000000,0x000400fa,0x00000135,0x00000137,0x0000013a,0x000200f8,0x00000137,0x0004003d, + 0x00000007,0x00000139,0x0000012d,0x0003003e,0x00000136,0x00000139,0x000200f9,0x00000138, + 0x000200f8,0x0000013a,0x00050041,0x0000012e,0x0000013b,0x0000012d,0x00000024,0x0004003d, + 0x00000006,0x0000013c,0x0000013b,0x00050085,0x00000006,0x0000013e,0x0000013c,0x0000013d, + 0x0004003d,0x00000006,0x0000013f,0x00000127,0x00050083,0x00000006,0x00000140,0x0000013e, + 0x0000013f,0x00050041,0x0000012e,0x00000141,0x0000012d,0x0000002b,0x0004003d,0x00000006, + 0x00000142,0x00000141,0x00050050,0x00000007,0x00000143,0x00000140,0x00000142,0x0003003e, + 0x00000136,0x00000143,0x000200f9,0x00000138,0x000200f8,0x00000138,0x0004003d,0x00000007, + 0x00000144,0x00000136,0x0003003e,0x00000134,0x00000144,0x0004003d,0x0000003b,0x00000146, + 0x00000123,0x000300f7,0x00000149,0x00000000,0x000400fa,0x00000146,0x00000148,0x0000014a, + 0x000200f8,0x00000148,0x0003003e,0x00000147,0x0000003a,0x000200f9,0x00000149,0x000200f8, + 0x0000014a,0x0004003d,0x00000006,0x0000014b,0x00000127,0x000500b8,0x0000003b,0x0000014c, + 0x0000014b,0x0000003a,0x000300f7,0x0000014f,0x00000000,0x000400fa,0x0000014c,0x0000014e, + 0x00000152,0x000200f8,0x0000014e,0x00060041,0x00000025,0x00000150,0x00000020,0x00000036, + 0x00000024,0x0004003d,0x00000006,0x00000151,0x00000150,0x0003003e,0x0000014d,0x00000151, + 0x000200f9,0x0000014f,0x000200f8,0x00000152,0x00060041,0x00000025,0x00000153,0x00000020, + 0x00000036,0x00000024,0x0004003d,0x00000006,0x00000154,0x00000153,0x0004007f,0x00000006, + 0x00000155,0x00000154,0x0003003e,0x0000014d,0x00000155,0x000200f9,0x0000014f,0x000200f8, + 0x0000014f,0x0004003d,0x00000006,0x00000156,0x0000014d,0x00050081,0x00000006,0x00000157, + 0x0000003a,0x00000156,0x0003003e,0x00000147,0x00000157,0x000200f9,0x00000149,0x000200f8, + 0x00000149,0x0004003d,0x00000006,0x00000158,0x00000147,0x0003003e,0x00000145,0x00000158, + 0x0004003d,0x00000007,0x0000015a,0x00000134,0x0004003d,0x00000006,0x0000015b,0x00000145, + 0x00050050,0x00000007,0x0000015c,0x0000015b,0x0000003a,0x00050083,0x00000007,0x0000015d, + 0x0000015a,0x0000015c,0x0003003e,0x00000159,0x0000015d,0x00060041,0x00000025,0x0000015f, + 0x00000020,0x00000022,0x00000037,0x0004003d,0x00000006,0x00000160,0x0000015f,0x0003003e, + 0x0000015e,0x00000160,0x00050041,0x00000009,0x00000162,0x00000159,0x00000024,0x0004003d, + 0x00000006,0x00000163,0x00000162,0x00060041,0x00000025,0x00000164,0x00000020,0x00000036, + 0x00000046,0x0004003d,0x00000006,0x00000165,0x00000164,0x00050085,0x00000006,0x00000166, + 0x00000163,0x00000165,0x00050041,0x00000009,0x00000167,0x00000159,0x0000002b,0x0004003d, + 0x00000006,0x00000168,0x00000167,0x00050050,0x00000007,0x00000169,0x00000166,0x00000168, + 0x0005008e,0x00000007,0x0000016a,0x00000169,0x0000013d,0x0004003d,0x00000006,0x0000016b, + 0x0000015e,0x0005008e,0x00000007,0x0000016c,0x0000016a,0x0000016b,0x0003003e,0x00000161, + 0x0000016c,0x00060041,0x00000025,0x0000016d,0x00000020,0x00000022,0x00000046,0x0004003d, + 0x00000006,0x0000016e,0x0000016d,0x000500ba,0x0000003b,0x0000016f,0x0000016e,0x0000006f, + 0x000300f7,0x00000171,0x00000000,0x000400fa,0x0000016f,0x00000170,0x00000197,0x000200f8, + 0x00000170,0x00060041,0x00000025,0x00000173,0x00000020,0x00000022,0x00000046,0x0004003d, + 0x00000006,0x00000174,0x00000173,0x00050083,0x00000006,0x00000175,0x0000001c,0x00000174, + 0x0004003d,0x00000007,0x00000177,0x00000161,0x0003003e,0x00000176,0x00000177,0x0003003e, + 0x00000178,0x00000175,0x00060039,0x00000007,0x00000179,0x0000000d,0x00000176,0x00000178, + 0x0003003e,0x0000017a,0x00000179,0x0004003d,0x00000006,0x0000017c,0x00000127,0x0003003e, + 0x0000017b,0x0000017c,0x00060039,0x0000000f,0x0000017d,0x00000013,0x0000017a,0x0000017b, + 0x00050051,0x00000006,0x0000017e,0x0000017d,0x00000000,0x00050041,0x00000009,0x0000017f, + 0x00000172,0x00000024,0x0003003e,0x0000017f,0x0000017e,0x0004003d,0x00000007,0x00000181, + 0x00000161,0x0003003e,0x00000180,0x00000181,0x0003003e,0x00000182,0x0000001c,0x00060039, + 0x00000007,0x00000183,0x0000000d,0x00000180,0x00000182,0x0003003e,0x00000184,0x00000183, + 0x0004003d,0x00000006,0x00000186,0x00000127,0x0003003e,0x00000185,0x00000186,0x00060039, + 0x0000000f,0x00000187,0x00000013,0x00000184,0x00000185,0x00050051,0x00000006,0x00000188, + 0x00000187,0x00000001,0x00050041,0x00000009,0x00000189,0x00000172,0x0000002b,0x0003003e, + 0x00000189,0x00000188,0x00060041,0x00000025,0x0000018a,0x00000020,0x00000022,0x00000046, + 0x0004003d,0x00000006,0x0000018b,0x0000018a,0x00050081,0x00000006,0x0000018c,0x0000001c, + 0x0000018b,0x0004003d,0x00000007,0x0000018e,0x00000161,0x0003003e,0x0000018d,0x0000018e, + 0x0003003e,0x0000018f,0x0000018c,0x00060039,0x00000007,0x00000190,0x0000000d,0x0000018d, + 0x0000018f,0x0003003e,0x00000191,0x00000190,0x0004003d,0x00000006,0x00000193,0x00000127, + 0x0003003e,0x00000192,0x00000193,0x00060039,0x0000000f,0x00000194,0x00000013,0x00000191, + 0x00000192,0x00050051,0x00000006,0x00000195,0x00000194,0x00000002,0x00050041,0x00000009, + 0x00000196,0x00000172,0x00000037,0x0003003e,0x00000196,0x00000195,0x000200f9,0x00000171, + 0x000200f8,0x00000197,0x0004003d,0x00000007,0x00000199,0x00000161,0x0003003e,0x00000198, + 0x00000199,0x0003003e,0x0000019a,0x0000001c,0x00060039,0x00000007,0x0000019b,0x0000000d, + 0x00000198,0x0000019a,0x0003003e,0x0000019c,0x0000019b,0x0004003d,0x00000006,0x0000019e, + 0x00000127,0x0003003e,0x0000019d,0x0000019e,0x00060039,0x0000000f,0x0000019f,0x00000013, + 0x0000019c,0x0000019d,0x0003003e,0x00000172,0x0000019f,0x000200f9,0x00000171,0x000200f8, + 0x00000171,0x0004003d,0x00000007,0x000001a1,0x00000134,0x0004003d,0x00000007,0x000001a2, + 0x00000134,0x00050050,0x00000007,0x000001a3,0x0000001c,0x0000001c,0x00050083,0x00000007, + 0x000001a4,0x000001a3,0x000001a2,0x0007000c,0x00000007,0x000001a5,0x00000001,0x00000025, + 0x000001a1,0x000001a4,0x0003003e,0x000001a0,0x000001a5,0x00050041,0x00000009,0x000001a8, + 0x000001a0,0x00000024,0x0004003d,0x00000006,0x000001a9,0x000001a8,0x00060041,0x00000025, + 0x000001aa,0x00000020,0x00000036,0x00000046,0x0004003d,0x00000006,0x000001ab,0x000001aa, + 0x00050085,0x00000006,0x000001ac,0x000001a9,0x000001ab,0x00050041,0x00000009,0x000001ad, + 0x000001a0,0x0000002b,0x0004003d,0x00000006,0x000001ae,0x000001ad,0x0007000c,0x00000006, + 0x000001af,0x00000001,0x00000025,0x000001ac,0x000001ae,0x0008000c,0x00000006,0x000001b0, + 0x00000001,0x00000031,0x0000006f,0x000001a7,0x000001af,0x0003003e,0x000001a6,0x000001b0, + 0x0004003d,0x0000000f,0x000001b3,0x00000172,0x0004003d,0x00000006,0x000001b4,0x000001a6, + 0x0005008e,0x0000000f,0x000001b5,0x000001b3,0x000001b4,0x00050051,0x00000006,0x000001b6, + 0x000001b5,0x00000000,0x00050051,0x00000006,0x000001b7,0x000001b5,0x00000001,0x00050051, + 0x00000006,0x000001b8,0x000001b5,0x00000002,0x00070050,0x0000001d,0x000001b9,0x000001b6, + 0x000001b7,0x000001b8,0x0000001c,0x0003003e,0x000001b2,0x000001b9,0x000100fd,0x00010038, + 0x00050036,0x00000007,0x0000000d,0x00000000,0x0000000a,0x00030037,0x00000008,0x0000000b, + 0x00030037,0x00000009,0x0000000c,0x000200f8,0x0000000e,0x0004003b,0x00000009,0x00000015, + 0x00000007,0x0004003d,0x00000007,0x00000016,0x0000000b,0x0004003d,0x00000007,0x00000017, + 0x0000000b,0x00050094,0x00000006,0x00000018,0x00000016,0x00000017,0x0003003e,0x00000015, + 0x00000018,0x0004003d,0x00000007,0x00000019,0x0000000b,0x0004003d,0x00000006,0x0000001a, + 0x0000000c,0x0005008e,0x00000007,0x0000001b,0x00000019,0x0000001a,0x00060041,0x00000025, + 0x00000026,0x00000020,0x00000022,0x00000024,0x0004003d,0x00000006,0x00000027,0x00000026, + 0x0004003d,0x00000006,0x00000028,0x00000015,0x00050085,0x00000006,0x00000029,0x00000027, + 0x00000028,0x00050081,0x00000006,0x0000002a,0x0000001c,0x00000029,0x00060041,0x00000025, + 0x0000002c,0x00000020,0x00000022,0x0000002b,0x0004003d,0x00000006,0x0000002d,0x0000002c, + 0x0004003d,0x00000006,0x0000002e,0x00000015,0x00050085,0x00000006,0x0000002f,0x0000002d, + 0x0000002e,0x0004003d,0x00000006,0x00000030,0x00000015,0x00050085,0x00000006,0x00000031, + 0x0000002f,0x00000030,0x00050081,0x00000006,0x00000032,0x0000002a,0x00000031,0x0005008e, + 0x00000007,0x00000033,0x0000001b,0x00000032,0x000200fe,0x00000033,0x00010038,0x00050036, + 0x0000000f,0x00000013,0x00000000,0x00000010,0x00030037,0x00000008,0x00000011,0x00030037, + 0x00000009,0x00000012,0x000200f8,0x00000014,0x0004003b,0x00000009,0x0000003f,0x00000007, + 0x0004003b,0x00000008,0x00000042,0x00000007,0x0004003b,0x00000008,0x00000059,0x00000007, + 0x0004003b,0x000000a2,0x000000a3,0x00000007,0x0004003b,0x000000bf,0x000000c0,0x00000007, + 0x0004003b,0x000000bf,0x000000cb,0x00000007,0x0004003b,0x00000009,0x000000e4,0x00000007, + 0x0004003b,0x000000bf,0x000000f3,0x00000007,0x0004003b,0x00000009,0x000000f9,0x00000007, + 0x0004003b,0x00000009,0x000000fc,0x00000007,0x0004003b,0x00000008,0x00000101,0x00000007, + 0x00060041,0x00000025,0x00000038,0x00000020,0x00000036,0x00000037,0x0004003d,0x00000006, + 0x00000039,0x00000038,0x000500ba,0x0000003b,0x0000003c,0x00000039,0x0000003a,0x000300f7, + 0x0000003e,0x00000000,0x000400fa,0x0000003c,0x0000003d,0x0000003e,0x000200f8,0x0000003d, + 0x00060041,0x00000025,0x00000040,0x00000020,0x00000022,0x00000037,0x0004003d,0x00000006, + 0x00000041,0x00000040,0x0003003e,0x0000003f,0x00000041,0x00050041,0x00000009,0x00000043, + 0x00000011,0x00000024,0x0004003d,0x00000006,0x00000044,0x00000043,0x0004003d,0x00000006, + 0x00000045,0x0000003f,0x00060041,0x00000025,0x00000047,0x00000020,0x00000036,0x00000046, + 0x0004003d,0x00000006,0x00000048,0x00000047,0x00050085,0x00000006,0x00000049,0x00000045, + 0x00000048,0x00050088,0x00000006,0x0000004a,0x00000044,0x00000049,0x00050041,0x00000009, + 0x0000004b,0x00000011,0x0000002b,0x0004003d,0x00000006,0x0000004c,0x0000004b,0x0004003d, + 0x00000006,0x0000004d,0x0000003f,0x00050088,0x00000006,0x0000004e,0x0000004c,0x0000004d, + 0x00050050,0x00000007,0x0000004f,0x0000004a,0x0000004e,0x0005008e,0x00000007,0x00000050, + 0x0000004f,0x0000003a,0x00050050,0x00000007,0x00000051,0x0000003a,0x0000003a,0x00050081, + 0x00000007,0x00000052,0x00000050,0x00000051,0x0003003e,0x00000042,0x00000052,0x00060041, + 0x00000025,0x00000053,0x00000020,0x00000036,0x00000037,0x0004003d,0x00000006,0x00000054, + 0x00000053,0x000500ba,0x0000003b,0x00000056,0x00000054,0x00000055,0x000300f7,0x00000058, + 0x00000000,0x000400fa,0x00000056,0x00000057,0x00000058,0x000200f8,0x00000057,0x00060041, + 0x00000025,0x0000005a,0x00000020,0x00000036,0x00000046,0x0004003d,0x00000006,0x0000005b, + 0x0000005a,0x00060041,0x00000025,0x0000005c,0x00000020,0x00000036,0x0000002b,0x0004003d, + 0x00000006,0x0000005d,0x0000005c,0x00050088,0x00000006,0x0000005e,0x0000005b,0x0000005d, + 0x00060041,0x00000025,0x0000005f,0x00000020,0x00000036,0x0000002b,0x0004003d,0x00000006, + 0x00000060,0x0000005f,0x00060041,0x00000025,0x00000061,0x00000020,0x00000036,0x00000046, + 0x0004003d,0x00000006,0x00000062,0x00000061,0x00050088,0x00000006,0x00000063,0x00000060, + 0x00000062,0x00050050,0x00000007,0x00000064,0x0000005e,0x00000063,0x0007000c,0x00000007, + 0x00000066,0x00000001,0x00000028,0x00000064,0x00000065,0x0003003e,0x00000059,0x00000066, + 0x0004003d,0x00000007,0x00000067,0x00000042,0x00050050,0x00000007,0x00000068,0x0000003a, + 0x0000003a,0x00050083,0x00000007,0x00000069,0x00000067,0x00000068,0x0004003d,0x00000007, + 0x0000006a,0x00000059,0x00050085,0x00000007,0x0000006b,0x00000069,0x0000006a,0x00050050, + 0x00000007,0x0000006c,0x0000003a,0x0000003a,0x00050081,0x00000007,0x0000006d,0x0000006b, + 0x0000006c,0x0003003e,0x00000042,0x0000006d,0x0004003d,0x00000007,0x0000006e,0x00000042, + 0x000500b8,0x00000071,0x00000072,0x0000006e,0x00000070,0x0004009a,0x0000003b,0x00000073, + 0x00000072,0x000400a8,0x0000003b,0x00000074,0x00000073,0x000300f7,0x00000076,0x00000000, + 0x000400fa,0x00000074,0x00000075,0x00000076,0x000200f8,0x00000075,0x0004003d,0x00000007, + 0x00000077,0x00000042,0x000500ba,0x00000071,0x00000078,0x00000077,0x00000065,0x0004009a, + 0x0000003b,0x00000079,0x00000078,0x000200f9,0x00000076,0x000200f8,0x00000076,0x000700f5, + 0x0000003b,0x0000007a,0x00000073,0x00000057,0x00000079,0x00000075,0x000300f7,0x0000007c, + 0x00000000,0x000400fa,0x0000007a,0x0000007b,0x0000007c,0x000200f8,0x0000007b,0x000200fe, + 0x0000007d,0x000200f8,0x0000007c,0x0004003d,0x00000080,0x00000083,0x00000082,0x0004003d, + 0x00000007,0x00000084,0x00000042,0x00050057,0x0000001d,0x00000085,0x00000083,0x00000084, + 0x0008004f,0x0000000f,0x00000086,0x00000085,0x00000085,0x00000000,0x00000001,0x00000002, + 0x000200fe,0x00000086,0x000200f8,0x00000058,0x0004003d,0x00000007,0x00000088,0x00000042, + 0x000500b8,0x00000071,0x00000089,0x00000088,0x00000070,0x0004009a,0x0000003b,0x0000008a, + 0x00000089,0x000400a8,0x0000003b,0x0000008b,0x0000008a,0x000300f7,0x0000008d,0x00000000, + 0x000400fa,0x0000008b,0x0000008c,0x0000008d,0x000200f8,0x0000008c,0x0004003d,0x00000007, + 0x0000008e,0x00000042,0x000500ba,0x00000071,0x0000008f,0x0000008e,0x00000065,0x0004009a, + 0x0000003b,0x00000090,0x0000008f,0x000200f9,0x0000008d,0x000200f8,0x0000008d,0x000700f5, + 0x0000003b,0x00000091,0x0000008a,0x00000058,0x00000090,0x0000008c,0x000300f7,0x00000093, + 0x00000000,0x000400fa,0x00000091,0x00000092,0x00000093,0x000200f8,0x00000092,0x000200fe, + 0x0000007d,0x000200f8,0x00000093,0x0004003d,0x00000080,0x00000095,0x00000082,0x00050041, + 0x00000009,0x00000096,0x00000042,0x00000024,0x0004003d,0x00000006,0x00000097,0x00000096, + 0x0004003d,0x00000006,0x00000098,0x00000012,0x00050081,0x00000006,0x00000099,0x00000097, + 0x00000098,0x00050085,0x00000006,0x0000009a,0x00000099,0x0000003a,0x00050041,0x00000009, + 0x0000009b,0x00000042,0x0000002b,0x0004003d,0x00000006,0x0000009c,0x0000009b,0x00050050, + 0x00000007,0x0000009d,0x0000009a,0x0000009c,0x00050057,0x0000001d,0x0000009e,0x00000095, + 0x0000009d,0x0008004f,0x0000000f,0x0000009f,0x0000009e,0x0000009e,0x00000000,0x00000001, + 0x00000002,0x000200fe,0x0000009f,0x000200f8,0x0000003e,0x00050041,0x000000a5,0x000000a6, + 0x00000020,0x000000a4,0x0004003d,0x0000001d,0x000000a7,0x000000a6,0x0008004f,0x0000000f, + 0x000000a8,0x000000a7,0x000000a7,0x00000000,0x00000001,0x00000002,0x00050041,0x000000a5, + 0x000000aa,0x00000020,0x000000a9,0x0004003d,0x0000001d,0x000000ab,0x000000aa,0x0008004f, + 0x0000000f,0x000000ac,0x000000ab,0x000000ab,0x00000000,0x00000001,0x00000002,0x00050041, + 0x000000a5,0x000000ae,0x00000020,0x000000ad,0x0004003d,0x0000001d,0x000000af,0x000000ae, + 0x0008004f,0x0000000f,0x000000b0,0x000000af,0x000000af,0x00000000,0x00000001,0x00000002, + 0x00050051,0x00000006,0x000000b1,0x000000a8,0x00000000,0x00050051,0x00000006,0x000000b2, + 0x000000a8,0x00000001,0x00050051,0x00000006,0x000000b3,0x000000a8,0x00000002,0x00050051, + 0x00000006,0x000000b4,0x000000ac,0x00000000,0x00050051,0x00000006,0x000000b5,0x000000ac, + 0x00000001,0x00050051,0x00000006,0x000000b6,0x000000ac,0x00000002,0x00050051,0x00000006, + 0x000000b7,0x000000b0,0x00000000,0x00050051,0x00000006,0x000000b8,0x000000b0,0x00000001, + 0x00050051,0x00000006,0x000000b9,0x000000b0,0x00000002,0x00060050,0x0000000f,0x000000ba, + 0x000000b1,0x000000b2,0x000000b3,0x00060050,0x0000000f,0x000000bb,0x000000b4,0x000000b5, + 0x000000b6,0x00060050,0x0000000f,0x000000bc,0x000000b7,0x000000b8,0x000000b9,0x00060050, + 0x000000a1,0x000000bd,0x000000ba,0x000000bb,0x000000bc,0x00040054,0x000000a1,0x000000be, + 0x000000bd,0x0003003e,0x000000a3,0x000000be,0x0004003d,0x000000a1,0x000000c1,0x000000a3, + 0x00050041,0x00000009,0x000000c2,0x00000011,0x00000024,0x0004003d,0x00000006,0x000000c3, + 0x000000c2,0x00050041,0x00000009,0x000000c4,0x00000011,0x0000002b,0x0004003d,0x00000006, + 0x000000c5,0x000000c4,0x0004007f,0x00000006,0x000000c6,0x000000c5,0x00060050,0x0000000f, + 0x000000c8,0x000000c3,0x000000c6,0x000000c7,0x0006000c,0x0000000f,0x000000c9,0x00000001, + 0x00000045,0x000000c8,0x00050091,0x0000000f,0x000000ca,0x000000c1,0x000000c9,0x0003003e, + 0x000000c0,0x000000ca,0x00050041,0x000000a5,0x000000cd,0x00000020,0x000000cc,0x0004003d, + 0x0000001d,0x000000ce,0x000000cd,0x0008004f,0x0000000f,0x000000cf,0x000000ce,0x000000ce, + 0x00000001,0x00000002,0x00000003,0x0004003d,0x000000a1,0x000000d0,0x000000a3,0x0004003d, + 0x00000006,0x000000d1,0x00000012,0x000500b8,0x0000003b,0x000000d2,0x000000d1,0x0000003a, + 0x000600a9,0x00000006,0x000000d3,0x000000d2,0x000000c7,0x0000001c,0x00060041,0x00000025, + 0x000000d4,0x00000020,0x000000a4,0x00000046,0x0004003d,0x00000006,0x000000d5,0x000000d4, + 0x00050085,0x00000006,0x000000d6,0x000000d3,0x000000d5,0x00060050,0x0000000f,0x000000d7, + 0x000000d6,0x0000006f,0x0000006f,0x00050091,0x0000000f,0x000000d8,0x000000d0,0x000000d7, + 0x00050081,0x0000000f,0x000000d9,0x000000cf,0x000000d8,0x0003003e,0x000000cb,0x000000d9, + 0x00050041,0x00000009,0x000000da,0x000000c0,0x00000037,0x0004003d,0x00000006,0x000000db, + 0x000000da,0x000500ba,0x0000003b,0x000000dd,0x000000db,0x000000dc,0x000300f7,0x000000df, + 0x00000000,0x000400fa,0x000000dd,0x000000de,0x000000df,0x000200f8,0x000000de,0x000200fe, + 0x000000e2,0x000200f8,0x000000df,0x00060041,0x00000025,0x000000e5,0x00000020,0x000000a9, + 0x00000046,0x0004003d,0x00000006,0x000000e6,0x000000e5,0x0004007f,0x00000006,0x000000e7, + 0x000000e6,0x00050041,0x00000009,0x000000e8,0x000000cb,0x00000037,0x0004003d,0x00000006, + 0x000000e9,0x000000e8,0x00050083,0x00000006,0x000000ea,0x000000e7,0x000000e9,0x00050041, + 0x00000009,0x000000eb,0x000000c0,0x00000037,0x0004003d,0x00000006,0x000000ec,0x000000eb, + 0x00050088,0x00000006,0x000000ed,0x000000ea,0x000000ec,0x0003003e,0x000000e4,0x000000ed, + 0x0004003d,0x00000006,0x000000ee,0x000000e4,0x000500bc,0x0000003b,0x000000ef,0x000000ee, + 0x0000006f,0x000300f7,0x000000f1,0x00000000,0x000400fa,0x000000ef,0x000000f0,0x000000f1, + 0x000200f8,0x000000f0,0x000200fe,0x000000e2,0x000200f8,0x000000f1,0x0004003d,0x0000000f, + 0x000000f4,0x000000cb,0x0004003d,0x0000000f,0x000000f5,0x000000c0,0x0004003d,0x00000006, + 0x000000f6,0x000000e4,0x0005008e,0x0000000f,0x000000f7,0x000000f5,0x000000f6,0x00050081, + 0x0000000f,0x000000f8,0x000000f4,0x000000f7,0x0003003e,0x000000f3,0x000000f8,0x00060041, + 0x00000025,0x000000fa,0x00000020,0x000000ad,0x00000046,0x0004003d,0x00000006,0x000000fb, + 0x000000fa,0x0003003e,0x000000f9,0x000000fb,0x0004003d,0x00000006,0x000000fd,0x000000f9, + 0x00060041,0x00000025,0x000000fe,0x00000020,0x00000036,0x0000002b,0x0004003d,0x00000006, + 0x000000ff,0x000000fe,0x00050088,0x00000006,0x00000100,0x000000fd,0x000000ff,0x0003003e, + 0x000000fc,0x00000100,0x00050041,0x00000009,0x00000102,0x000000f3,0x00000024,0x0004003d, + 0x00000006,0x00000103,0x00000102,0x0004003d,0x00000006,0x00000104,0x000000f9,0x00050088, + 0x00000006,0x00000105,0x00000103,0x00000104,0x00050041,0x00000009,0x00000106,0x000000f3, + 0x0000002b,0x0004003d,0x00000006,0x00000107,0x00000106,0x0004007f,0x00000006,0x00000108, + 0x00000107,0x0004003d,0x00000006,0x00000109,0x000000fc,0x00050088,0x00000006,0x0000010a, + 0x00000108,0x00000109,0x00050050,0x00000007,0x0000010b,0x00000105,0x0000010a,0x0005008e, + 0x00000007,0x0000010c,0x0000010b,0x0000003a,0x00050050,0x00000007,0x0000010d,0x0000003a, + 0x0000003a,0x00050081,0x00000007,0x0000010e,0x0000010c,0x0000010d,0x0003003e,0x00000101, + 0x0000010e,0x0004003d,0x00000007,0x0000010f,0x00000101,0x000500b8,0x00000071,0x00000110, + 0x0000010f,0x00000070,0x0004009a,0x0000003b,0x00000111,0x00000110,0x000400a8,0x0000003b, + 0x00000112,0x00000111,0x000300f7,0x00000114,0x00000000,0x000400fa,0x00000112,0x00000113, + 0x00000114,0x000200f8,0x00000113,0x0004003d,0x00000007,0x00000115,0x00000101,0x000500ba, + 0x00000071,0x00000116,0x00000115,0x00000065,0x0004009a,0x0000003b,0x00000117,0x00000116, + 0x000200f9,0x00000114,0x000200f8,0x00000114,0x000700f5,0x0000003b,0x00000118,0x00000111, + 0x000000f1,0x00000117,0x00000113,0x000300f7,0x0000011a,0x00000000,0x000400fa,0x00000118, + 0x00000119,0x0000011a,0x000200f8,0x00000119,0x000200fe,0x000000e2,0x000200f8,0x0000011a, + 0x0004003d,0x00000080,0x0000011c,0x00000082,0x0004003d,0x00000007,0x0000011d,0x00000101, + 0x00050057,0x0000001d,0x0000011e,0x0000011c,0x0000011d,0x0008004f,0x0000000f,0x0000011f, + 0x0000011e,0x0000011e,0x00000000,0x00000001,0x00000002,0x000200fe,0x0000011f,0x00010038 }; diff --git a/app/src/main/cpp/waylandcomp/src/compositor.c b/app/src/main/cpp/waylandcomp/src/compositor.c index 145406264c..983d8abb8d 100644 --- a/app/src/main/cpp/waylandcomp/src/compositor.c +++ b/app/src/main/cpp/waylandcomp/src/compositor.c @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include @@ -281,7 +282,9 @@ volatile int g_ubwc = 1; volatile int g_no_render_node; -volatile int g_output_refresh_mhz; +static atomic_int g_output_refresh_mhz = 60000; +static atomic_int g_output_refresh_pending; +static int g_output_announced_refresh_mhz = 60000; volatile int g_output_w, g_output_h; struct pending_release { @@ -736,6 +739,7 @@ static void take_pixel(struct surface *s, const uint8_t bgra[4], struct wl_resou static struct surface *g_hud_surface; static int64_t g_hud_last_ns, g_hud_alive_ns; static int g_hud_fresh; +static uint64_t g_game_frames; extern void droiddeck_on_game_surface(const char *window, const char *gpu); extern void droiddeck_on_game_frame(void); extern void droiddeck_on_game_program(int pid, const char *program); @@ -819,10 +823,12 @@ static void take_dmabuf(struct surface *s, struct dmabuf_buffer *b, struct wl_re } if (s == g_hud_surface) { g_hud_alive_ns = now_ns(); - if (!repeat) { g_hud_last_ns = g_hud_alive_ns; g_hud_fresh = 1; droiddeck_on_game_frame(); } + if (!repeat) { g_hud_last_ns = g_hud_alive_ns; g_hud_fresh = 1; g_game_frames++; droiddeck_on_game_frame(); } } } +uint64_t droiddeck_game_frames(void) { return g_game_frames; } + struct dmabuf_buffer *droiddeck_dmabuf_from_resource(struct wl_resource *buffer) { return get_dmabuf(buffer); } int droiddeck_dmabuf_fd(const struct dmabuf_buffer *b) { return b && b->n_planes > 0 ? b->fd[0] : -1; } void droiddeck_dmabuf_size(const struct dmabuf_buffer *b, int *w, int *h) { *w = b->width; *h = b->height; } @@ -874,7 +880,7 @@ static void feedback_discard_all(struct wl_list *list) { } static uint32_t nominal_refresh_ns(void) { - int mhz = g_output_refresh_mhz; + int mhz = atomic_load(&g_output_refresh_mhz); if (mhz <= 0) mhz = 60000; return (uint32_t)(1000000000000LL / (int64_t)mhz); } @@ -1588,10 +1594,10 @@ static const struct wl_output_interface output_impl = { .release = output_releas static struct wl_list g_outputs; static void output_resource_destroy(struct wl_resource *r) { wl_list_remove(wl_resource_get_link(r)); } -static void output_send_mode(struct wl_resource *r) { +static void output_send_mode(struct wl_resource *r, int mhz) { wl_output_send_mode(r, WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED, g_output_w > 0 ? g_output_w : 1920, g_output_h > 0 ? g_output_h : 1080, - g_output_refresh_mhz > 0 ? g_output_refresh_mhz : 60000); + mhz); } static void bind_output(struct wl_client *c, void *data, uint32_t ver, uint32_t id) { @@ -1601,7 +1607,7 @@ static void bind_output(struct wl_client *c, void *data, uint32_t ver, uint32_t wl_list_insert(&g_outputs, wl_resource_get_link(r)); wl_output_send_geometry(r, 0, 0, 340, 190, WL_OUTPUT_SUBPIXEL_UNKNOWN, "DroidDeck", "Wayland", WL_OUTPUT_TRANSFORM_NORMAL); - output_send_mode(r); + output_send_mode(r, g_output_announced_refresh_mhz); if (ver >= WL_OUTPUT_NAME_SINCE_VERSION) { wl_output_send_name(r, "DroidDeck-1"); wl_output_send_description(r, "DroidDeck display"); @@ -2916,10 +2922,19 @@ static void deliver_key(const struct input_msg *m) { key_event((uint32_t)m->p1, m->p2); } -static void scroll_event(int steps) { +static void send_axis(struct seat_pointer *sp, uint32_t t, uint32_t axis, int value120) { + if (!value120) return; + if (wl_resource_get_version(sp->ptr) >= WL_POINTER_AXIS_VALUE120_SINCE_VERSION) + wl_pointer_send_axis_value120(sp->ptr, axis, value120); + else if (wl_resource_get_version(sp->ptr) >= WL_POINTER_AXIS_DISCRETE_SINCE_VERSION && value120 % 120 == 0) + wl_pointer_send_axis_discrete(sp->ptr, axis, value120 / 120); + wl_pointer_send_axis(sp->ptr, t, axis, wl_fixed_from_double(value120 / 12.0)); +} + +static void axis_event(int vertical120, int horizontal120) { struct surface *target = g_active_constraint ? g_active_constraint->surface : g_desktop ? g_desktop : (g_grab ? g_grab : toplevel_at(g_ptr_x, g_ptr_y)); - if (!target || !steps) return; + if (!target || (!vertical120 && !horizontal120)) return; struct wl_client *client = wl_resource_get_client(target->resource); struct seat_pointer *sp; if (!pointer_for(client)) return; @@ -2928,17 +2943,18 @@ static void scroll_event(int steps) { uint32_t t = now_ms(); pointer_focus(target->resource, wl_fixed_from_double(g_ptr_x - tx), wl_fixed_from_double(g_ptr_y - ty)); for_each_pointer_of(client, sp) { - if (wl_resource_get_version(sp->ptr) >= WL_POINTER_AXIS_VALUE120_SINCE_VERSION) - wl_pointer_send_axis_value120(sp->ptr, WL_POINTER_AXIS_VERTICAL_SCROLL, steps * 120); - else if (wl_resource_get_version(sp->ptr) >= WL_POINTER_AXIS_DISCRETE_SINCE_VERSION) - wl_pointer_send_axis_discrete(sp->ptr, WL_POINTER_AXIS_VERTICAL_SCROLL, steps); - wl_pointer_send_axis(sp->ptr, t, WL_POINTER_AXIS_VERTICAL_SCROLL, wl_fixed_from_int(steps * 10)); + send_axis(sp, t, WL_POINTER_AXIS_VERTICAL_SCROLL, vertical120); + send_axis(sp, t, WL_POINTER_AXIS_HORIZONTAL_SCROLL, horizontal120); if (wl_resource_get_version(sp->ptr) >= WL_POINTER_FRAME_SINCE_VERSION) wl_pointer_send_frame(sp->ptr); } wl_display_flush_clients(g_display); } +static void scroll_event(int steps) { + axis_event(steps * 120, 0); +} + static int update_modifiers(uint32_t evdev, int pressed) { static const struct { uint32_t evdev, mask; } mod_keys[] = { { 42, 0x1 }, { 54, 0x1 }, @@ -2994,13 +3010,19 @@ static void key_event(uint32_t evdev, int pressed) { wl_display_flush_clients(g_display); } -static void output_resized(void) { - struct surface *s; +static void output_notify_mode(void) { + int mhz = atomic_load(&g_output_refresh_mhz); struct wl_resource *r; wl_resource_for_each(r, &g_outputs) { - output_send_mode(r); + output_send_mode(r, mhz); if (wl_resource_get_version(r) >= 2) wl_output_send_done(r); } + g_output_announced_refresh_mhz = mhz; +} + +static void output_resized(void) { + struct surface *s; + output_notify_mode(); wl_list_for_each(s, &g_surfaces, link) if (s->xdg_toplevel && s->toplevel_committed) send_toplevel_configure(s); droiddeck_log("display", "output resized to %dx%d", g_output_w, g_output_h); @@ -3009,13 +3031,15 @@ static void output_resized(void) { static int on_input_readable(int fd, uint32_t mask, void *data) { struct input_msg m; + int vsync = 0; + int64_t vsync_ns = 0; while (read(fd, &m, sizeof(m)) == (ssize_t)sizeof(m)) { switch (m.type) { case 1: deliver_key(&m); break; case 2: pointer_event(m.p1, m.p2, 0, 0); break; case 3: pointer_button(m.p1, m.p2); break; case 4: scroll_event(m.p1); break; - case 5: on_vsync(((int64_t)m.p1 << 32) | (uint32_t)m.p2); break; + case 5: vsync = 1; vsync_ns = ((int64_t)m.p1 << 32) | (uint32_t)m.p2; break; case 6: pointer_delta(m.p1 / 256.0, m.p2 / 256.0); break; case 7: deliver_touch(&m); break; case 8: output_resized(); break; @@ -3023,9 +3047,17 @@ static int on_input_readable(int fd, uint32_t mask, void *data) { vk_present_set_scale_mode(m.p1, m.p2); schedule_render(); break; + case 10: break; + case 11: axis_event(m.p1, m.p2); break; default: deliver_pointer(&m); break; } } + if (atomic_exchange(&g_output_refresh_pending, 0) && + atomic_load(&g_output_refresh_mhz) != g_output_announced_refresh_mhz) { + output_notify_mode(); + wl_display_flush_clients(g_display); + } + if (vsync) on_vsync(vsync_ns); return 0; } @@ -3067,6 +3099,16 @@ void droiddeck_wayland_output_resized(void) { (void)n; } +void droiddeck_wayland_set_output_refresh_rate(int mhz) { + if (mhz <= 0) mhz = 60000; + if (atomic_exchange(&g_output_refresh_mhz, mhz) == mhz || g_input_pipe[1] < 0) return; + atomic_store(&g_output_refresh_pending, 1); + struct input_msg m = { 10, 0, 0, 0, 0 }; + ssize_t n; + do { n = write(g_input_pipe[1], &m, sizeof(m)); } while (n < 0 && errno == EINTR); + (void)n; +} + void droiddeck_wayland_vsync(int64_t frame_time_ns) { if (g_input_pipe[1] < 0) return; struct input_msg m = { 5, (int)(frame_time_ns >> 32), (int)(uint32_t)frame_time_ns, 0, 0 }; @@ -3309,6 +3351,7 @@ int droiddeck_wayland_run(void) { if ((g_stats_timer = wl_event_loop_add_timer(wl_display_get_event_loop(display), on_stats_timer, NULL))) wl_event_source_timer_update(g_stats_timer, 10000); + g_output_announced_refresh_mhz = atomic_load(&g_output_refresh_mhz); wl_display_run(display); wl_display_destroy(display); diff --git a/app/src/main/cpp/waylandcomp/src/framegen_bridge.c b/app/src/main/cpp/waylandcomp/src/framegen_bridge.c index 3c311b54f7..379087045e 100644 --- a/app/src/main/cpp/waylandcomp/src/framegen_bridge.c +++ b/app/src/main/cpp/waylandcomp/src/framegen_bridge.c @@ -11,6 +11,7 @@ #include void droiddeck_log(const char *tag, const char *fmt, ...) __attribute__((format(printf, 2, 3))); +uint64_t droiddeck_game_frames(void); #define FGLOG(...) droiddeck_log("framegen", __VA_ARGS__) #define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, "DroidDeckWayland", __VA_ARGS__) @@ -372,7 +373,11 @@ int vkp_framegen_run(VkCommandBuffer cmd, VkImage scene, VkImageView scene_view, return 0; } - uint32_t n_gen = fge_plan(g_ring_n, ++g_source_frames, g_presented_rate); + /* The pacer's source rate must be the game's, not this loop's: a loop slowed by its own + * generations would otherwise read as a slower game and justify even more generations. */ + ++g_source_frames; + const uint64_t game_frames = droiddeck_game_frames(); + uint32_t n_gen = fge_plan(g_ring_n, game_frames ? game_frames : g_source_frames, g_presented_rate); if (n_gen > g_ring_n) n_gen = g_ring_n; g_planned = n_gen; diff --git a/app/src/main/cpp/waylandcomp/src/headpose_shm.h b/app/src/main/cpp/waylandcomp/src/headpose_shm.h index 1bed89e796..824232b431 100644 --- a/app/src/main/cpp/waylandcomp/src/headpose_shm.h +++ b/app/src/main/cpp/waylandcomp/src/headpose_shm.h @@ -9,6 +9,7 @@ enum { DROIDDECK_HEADPOSE_LIVE = 1u << 0, DROIDDECK_HEADPOSE_ENABLED = 1u << 1, + DROIDDECK_HEADPOSE_MONO = 1u << 2, }; struct droiddeck_headpose { @@ -22,7 +23,10 @@ struct droiddeck_headpose { float tan_half_fov; float eye_aspect; uint32_t eye_w, eye_h; - uint32_t reserved[12]; + float display_hz; + // Uses a formerly reserved word; older publishers leave this zero. + uint32_t render_height; + uint32_t reserved[10]; }; #ifdef __cplusplus diff --git a/app/src/main/cpp/waylandcomp/src/spatialpose.c b/app/src/main/cpp/waylandcomp/src/spatialpose.c new file mode 100644 index 0000000000..48f56905ae --- /dev/null +++ b/app/src/main/cpp/waylandcomp/src/spatialpose.c @@ -0,0 +1,59 @@ +#define _POSIX_C_SOURCE 200809L +#include "spatialpose_shm.h" +#include +#include +#include +#include +#include +#include +#include + +static pthread_mutex_t spatial_lock = PTHREAD_MUTEX_INITIALIZER; +static struct droiddeck_spatialpose *shared; + +JNIEXPORT jboolean JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetSpatialFile( + JNIEnv *env, jclass clazz, jstring path) { + (void)clazz; + pthread_mutex_lock(&spatial_lock); + if (!shared && path) { + const char *name = (*env)->GetStringUTFChars(env, path, NULL); + if (name) { + int fd = open(name, O_RDWR | O_CREAT | O_CLOEXEC, 0600); + (*env)->ReleaseStringUTFChars(env, path, name); + if (fd >= 0) { + if (ftruncate(fd, sizeof(*shared)) == 0) { + void *p = mmap(NULL, sizeof(*shared), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (p != MAP_FAILED) { + shared = p; + memset(shared, 0, sizeof(*shared)); + shared->magic = DROIDDECK_SPATIALPOSE_MAGIC; + shared->version = DROIDDECK_SPATIALPOSE_VERSION; + shared->size = sizeof(*shared); + } + } + close(fd); + } + } + } + jboolean ready = shared != NULL; + pthread_mutex_unlock(&spatial_lock); + return ready; +} + +JNIEXPORT void JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativePublishSpatial( + JNIEnv *env, jclass clazz, jobject buffer) { + (void)clazz; + if (!buffer || (*env)->GetDirectBufferCapacity(env, buffer) != sizeof(*shared)) return; + const struct droiddeck_spatialpose *src = (*env)->GetDirectBufferAddress(env, buffer); + if (!src || src->magic != DROIDDECK_SPATIALPOSE_MAGIC || src->version != DROIDDECK_SPATIALPOSE_VERSION || + src->size != sizeof(*shared)) return; + pthread_mutex_lock(&spatial_lock); + if (shared) { + unsigned seq = __atomic_load_n(&shared->seq, __ATOMIC_RELAXED); + __atomic_store_n(&shared->seq, seq | 1u, __ATOMIC_RELAXED); + __atomic_thread_fence(__ATOMIC_RELEASE); + memcpy((char *)shared + 16, (const char *)src + 16, sizeof(*shared) - 16); + __atomic_store_n(&shared->seq, (seq | 1u) + 1u, __ATOMIC_RELEASE); + } + pthread_mutex_unlock(&spatial_lock); +} diff --git a/app/src/main/cpp/waylandcomp/src/spatialpose_shm.h b/app/src/main/cpp/waylandcomp/src/spatialpose_shm.h new file mode 100644 index 0000000000..099188736b --- /dev/null +++ b/app/src/main/cpp/waylandcomp/src/spatialpose_shm.h @@ -0,0 +1,33 @@ +#ifndef DROIDDECK_SPATIALPOSE_SHM_H +#define DROIDDECK_SPATIALPOSE_SHM_H +#include +#define DROIDDECK_SPATIALPOSE_MAGIC 0x53504444u +#define DROIDDECK_SPATIALPOSE_VERSION 4u +#define DROIDDECK_SPATIALPOSE_FILE "droiddeck-spatialpose" +enum { DD_SPATIAL_ACTIVE = 1u, DD_SPATIAL_HANDS = 2u, DD_SPATIAL_JOYCONS = 4u, DD_SPATIAL_STEADY_AIM = 8u, DD_SPATIAL_VALID = 1u }; +enum { DD_SPATIAL_TRIGGER_VALID = 2u, DD_SPATIAL_GRIP_VALID = 4u }; +struct dd_spatial_pose { + int64_t time_ns; + float position[3]; + float rotation[4]; + uint32_t flags; +}; +struct dd_spatial_hand { + struct dd_spatial_pose pose; + float trigger; + uint32_t grip; +}; +struct droiddeck_spatialpose { + uint32_t magic, version, size, seq; + uint64_t connection, origin; + uint32_t flags, input_epochs; + struct dd_spatial_pose head; + struct dd_spatial_hand hands[2]; +}; +#ifdef __cplusplus +static_assert(sizeof(dd_spatial_pose) == 40, "spatial pose ABI"); +static_assert(sizeof(droiddeck_spatialpose) == 176, "spatial snapshot ABI"); +#else +_Static_assert(sizeof(struct droiddeck_spatialpose) == 176, "spatial snapshot ABI"); +#endif +#endif diff --git a/app/src/main/cpp/waylandcomp/src/vk_present.c b/app/src/main/cpp/waylandcomp/src/vk_present.c index 4e8c24d0bc..f171b3b930 100644 --- a/app/src/main/cpp/waylandcomp/src/vk_present.c +++ b/app/src/main/cpp/waylandcomp/src/vk_present.c @@ -195,6 +195,9 @@ static pthread_mutex_t g_req_lock = PTHREAD_MUTEX_INITIALIZER; static ANativeWindow *g_req_window; static int g_req_pending; static int g_req_detached; +static uint64_t g_req_generation, g_req_applied; +static pthread_cond_t g_req_condition = PTHREAD_COND_INITIALIZER; + static volatile int g_mode = VKP_MODE_STRETCH, g_align = VKP_ALIGN_CENTER; @@ -280,26 +283,53 @@ void vk_present_set_window(ANativeWindow *window) { if (g_req_pending && g_req_window && g_req_window != window) superseded = g_req_window; g_req_window = window; g_req_pending = 1; + g_req_generation++; if (!window) g_req_detached = 1; pthread_mutex_unlock(&g_req_lock); if (superseded) ANativeWindow_release(superseded); } +static void window_request_applied(uint64_t generation) { + pthread_mutex_lock(&g_req_lock); + g_req_applied = generation; + pthread_cond_broadcast(&g_req_condition); + pthread_mutex_unlock(&g_req_lock); +} + +int vkp_wait_window_request(int timeout_ms) { + if (timeout_ms <= 0 || timeout_ms > 10000) return 0; + struct timespec deadline; + clock_gettime(CLOCK_REALTIME, &deadline); + deadline.tv_sec += timeout_ms / 1000; + deadline.tv_nsec += (timeout_ms % 1000) * 1000000L; + if (deadline.tv_nsec >= 1000000000L) { deadline.tv_sec++; deadline.tv_nsec -= 1000000000L; } + pthread_mutex_lock(&g_req_lock); + const uint64_t generation = g_req_generation; + int error = 0; + while (g_req_applied < generation && error == 0) + error = pthread_cond_timedwait(&g_req_condition, &g_req_lock, &deadline); + int applied = g_req_applied >= generation; + pthread_mutex_unlock(&g_req_lock); + return applied; +} + int vkp_apply_window_request(void) { ANativeWindow *w; pthread_mutex_lock(&g_req_lock); if (!g_req_pending) { pthread_mutex_unlock(&g_req_lock); return 0; } w = g_req_window; const int detached = g_req_detached; + const uint64_t generation = g_req_generation; g_req_window = NULL; g_req_pending = 0; g_req_detached = 0; pthread_mutex_unlock(&g_req_lock); if (w == g_window) { if (w) ANativeWindow_release(w); - if (!w || !detached) return 0; + if (!w || !detached) { window_request_applied(generation); return 0; } sc_layer_window_gone(); destroy_swapchain(); + window_request_applied(generation); droiddeck_log("gpu", "screen surface rebound: rebuilding the swapchain at its new size"); return 1; } @@ -310,6 +340,7 @@ int vkp_apply_window_request(void) { g_window = w; g_swap_retry_at_ns = 0; g_swap_fail_logged = 0; + window_request_applied(generation); droiddeck_log("gpu", w ? "screen surface attached" : "screen surface gone: presenting paused"); 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 2909b3da37..1a5f6a244b 100644 --- a/app/src/main/cpp/waylandcomp/src/vk_present.h +++ b/app/src/main/cpp/waylandcomp/src/vk_present.h @@ -56,6 +56,7 @@ const char *vkp_gpu_name(void); int vkp_ready(void); int vkp_has_window(void); +int vkp_wait_window_request(int timeout_ms); int vkp_device_lost(void); /* Compositor thread only. Submitted reads may still be pending: retain imported * buffer references and withhold DMA-BUF releases until the app process exits. diff --git a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c index 54ddc0eb1c..d30b46173f 100644 --- a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c +++ b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c @@ -27,13 +27,13 @@ extern void droiddeck_wayland_send_key(int evdev, int state); extern void droiddeck_wayland_send_scene_input(int type, int a, int b); extern void droiddeck_wayland_vsync(int64_t frame_time_ns); extern void droiddeck_wayland_output_resized(void); +extern void droiddeck_wayland_set_output_refresh_rate(int mhz); extern volatile int g_fps_limit; extern volatile int g_hide_shell; extern volatile int g_zero_copy; extern volatile unsigned g_zero_copy_last; extern volatile int g_ubwc; extern volatile int g_no_render_node; -extern volatile int g_output_refresh_mhz; extern volatile int g_output_w, g_output_h; #define TAG "DroidDeckWayland" @@ -346,7 +346,7 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetLayerFrameRate(JN JNIEXPORT void JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetOutputRefreshRate(JNIEnv *env, jclass clazz, jfloat hz) { - g_output_refresh_mhz = hz > 1.0f ? (int)(hz * 1000.0f + 0.5f) : 0; + droiddeck_wayland_set_output_refresh_rate(hz > 1.0f ? (int)(hz * 1000.0f + 0.5f) : 0); } extern void vkp_reset_first_frame(void); @@ -360,6 +360,7 @@ JNIEXPORT void JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetOutputSize(JNIEnv *env, jclass clazz, jint w, jint h) { g_output_w = w > 0 ? w : 0; g_output_h = h > 0 ? h : 0; + vkp_cardboard_set_render_height(h); } JNIEXPORT void JNICALL @@ -368,6 +369,7 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeResizeOutput(JNIEnv if (w <= 0 || h <= 0) return; g_output_w = w; g_output_h = h; + vkp_cardboard_set_render_height(h); droiddeck_wayland_output_resized(); } @@ -420,10 +422,11 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetScreenEffects(JNI JNIEXPORT void JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetCardboard(JNIEnv *env, jclass clazz, jboolean enabled, - jint source, jfloat ipd, jfloat dist, jfloat width, jfloat k1, jfloat k2, jfloat fov, jfloat inset, jfloat chroma) { + jint source, jfloat ipd, jfloat dist, jfloat width, jfloat k1, jfloat k2, jfloat fov, jfloat inset, jfloat chroma, + jboolean mono, jfloat hz) { struct cardboard_params p = {.enabled = enabled ? 1 : 0, .source = source, .ipd_m = ipd, .screen_dist_m = dist, .screen_width_m = width, .k1 = k1, .k2 = k2, .fov_deg = fov, .lens_inset = inset, - .chroma = chroma}; + .chroma = chroma, .mono = mono ? 1 : 0, .display_hz = hz}; vkp_cardboard_set(&p); } @@ -610,6 +613,12 @@ static char *dup_bytes(JNIEnv *env, jbyteArray arr, int *len) { return buf; } +JNIEXPORT jboolean JNICALL +Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeWaitSurface( + JNIEnv *env, jclass clazz, jint timeout_ms) { + return vkp_wait_window_request(timeout_ms) ? JNI_TRUE : JNI_FALSE; +} + JNIEXPORT void JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetClipboardText(JNIEnv *env, jclass clazz, jbyteArray utf8) { int len; @@ -658,3 +667,14 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeRaisePriority(JNIEnv int after = getpriority(PRIO_PROCESS, (id_t)tid); return after == -1 && errno != 0 ? 100 : after; } + +JNIEXPORT void JNICALL +Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetCardboardSpatialPose(JNIEnv *env, jclass clazz, + jfloatArray rot, jfloatArray pos, jboolean live) { + (void)clazz; + if (!rot || !pos || (*env)->GetArrayLength(env, rot) != 9 || (*env)->GetArrayLength(env, pos) != 3) return; + float m[9], p[3]; + (*env)->GetFloatArrayRegion(env, rot, 0, 9, m); + (*env)->GetFloatArrayRegion(env, pos, 0, 3, p); + vkp_cardboard_set_spatial_pose(m, p, live ? 1 : 0); +} diff --git a/app/src/main/java/com/droiddeck/launcher/App.kt b/app/src/main/java/com/droiddeck/launcher/App.kt index 43d3ffc121..e0abe387d8 100644 --- a/app/src/main/java/com/droiddeck/launcher/App.kt +++ b/app/src/main/java/com/droiddeck/launcher/App.kt @@ -16,11 +16,19 @@ class App : Application() { override fun onCreate() { super.onCreate() + // Helper processes must not initialize the main USB provider or guest graphics context. + val process = if (android.os.Build.VERSION.SDK_INT >= 28) Application.getProcessName() + else (getSystemService(ACTIVITY_SERVICE) as android.app.ActivityManager) + .runningAppProcesses?.firstOrNull { it.pid == android.os.Process.myPid() }?.processName + if (process == "$packageName:vr_recovery" || process == "$packageName:rgb_diagnostic") return CrashHandler.install(this) com.droiddeck.launcher.session.QuestExperimental.initialize(this) com.droiddeck.launcher.session.SessionPrefs.settleGpuDriverMode(this) com.droiddeck.launcher.update.AppUpdates.init(this) + com.droiddeck.launcher.core.DownloadSource.init(this) GpuClockPin.clearLeftover(this) + com.droiddeck.launcher.glasses.Glasses.init(this) + com.droiddeck.launcher.glasses.GlassesMenuMirror.initialize(this) BwrapSpawner.start(this) com.droiddeck.launcher.frontend.GameFileSync.start(this) com.droiddeck.launcher.stores.StoresState.init(this) diff --git a/app/src/main/java/com/droiddeck/launcher/DriverMenus.kt b/app/src/main/java/com/droiddeck/launcher/DriverMenus.kt index 4818be7373..0c1c3fd92b 100644 --- a/app/src/main/java/com/droiddeck/launcher/DriverMenus.kt +++ b/app/src/main/java/com/droiddeck/launcher/DriverMenus.kt @@ -11,6 +11,7 @@ import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.setValue import androidx.compose.runtime.mutableIntStateOf +import com.droiddeck.launcher.gpu.AutoDriverTrial import com.droiddeck.launcher.gpu.DriverBundle import com.droiddeck.launcher.core.DeviceSupport import com.droiddeck.launcher.gpu.DriverPairs @@ -23,7 +24,12 @@ import com.droiddeck.launcher.gpu.TurnipReleases import com.droiddeck.launcher.session.SessionService import com.droiddeck.launcher.session.SessionPrefs import com.droiddeck.launcher.session.QuestExperimental +import com.droiddeck.launcher.session.SessionState import com.droiddeck.launcher.ui.DriverRow +import com.droiddeck.launcher.ui.DriverSlot +import com.droiddeck.launcher.ui.GPU_MODE_AUTO +import com.droiddeck.launcher.ui.GPU_MODE_MIX +import com.droiddeck.launcher.ui.GPU_MODE_PAIR import com.droiddeck.launcher.ui.GpuDriversState import com.droiddeck.launcher.ui.PairRow import com.droiddeck.launcher.wayland.CompositorHost @@ -45,7 +51,18 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl var pairPercent by mutableIntStateOf(-1) var autoStatus by mutableStateOf("") var activeBundle by mutableStateOf(null) - private var autoCheckedThisProcess = false + private var lastAutoCheck = 0L + private var pairModeOpen by mutableStateOf(false) + var restartPending by mutableStateOf(false) + private set + private var runtimePending by mutableStateOf(false) + private var sessionRunning by mutableStateOf(false) + + val uiMode: String get() = when (mode) { + SessionPrefs.GPU_DRIVERS_AUTO -> GPU_MODE_AUTO + SessionPrefs.GPU_DRIVERS_MIX -> GPU_MODE_MIX + else -> if (pairModeOpen || pairRows.any { it.active }) GPU_MODE_PAIR else GPU_MODE_MIX + } fun state() = GpuDriversState( gpuName = gpu.displayName(activity), gpuFamily = if (gpu.name.contains("Xclipse", ignoreCase = true)) gpu.family.label(gpu.name) else gpu.family.label(activity), soc = gpu.soc, supportText = gpu.supportText(activity), @@ -56,7 +73,56 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl linuxDownloads = linuxDownloads, androidDownloads = androidDownloads, canRestoreBundled = canRestoreBundled, activeBundle = activeBundle, powerVr = gpu.family == GpuInfo.Family.POWERVR, systemPowerVr = SystemVulkanDriver.usesDefault(linuxSelected), + mode = uiMode, display = displaySlot(), runtime = runtimeSlot(), + canRestart = !sessionRunning, + checkedAt = TurnipReleases.cached(activity)?.checkedAt ?: 0L, ) + + private fun slotSource(chosenDefault: Boolean, defaultLabel: Int): String = activity.getString(when { + uiMode == GPU_MODE_AUTO -> R.string.gpu_src_auto + uiMode == GPU_MODE_PAIR && pairRows.any { it.active } -> R.string.gpu_src_pair + activeBundle != null -> R.string.gpu_src_bundle + chosenDefault -> defaultLabel + else -> R.string.gpu_src_chosen + }) + + private fun displaySlot(): DriverSlot { + val row = androidRows.firstOrNull { it.id == androidSelected } + val live = androidRows.firstOrNull { it.id == CompositorHost.displayChoice }?.name + return DriverSlot( + name = row?.name ?: activity.getString(R.string.gpu_auto_by_gpu), + source = slotSource(androidSelected == TurnipDriver.AUTO, R.string.gpu_src_by_gpu), + pending = restartPending, + status = when { + restartPending -> activity.getString(R.string.gpu_display_pending, live ?: activity.getString(R.string.gpu_previous_driver)) + CompositorHost.isStarted -> activity.getString(R.string.gpu_display_live) + else -> activity.getString(R.string.gpu_display_next) + }, + ) + } + + private fun runtimeSlot(): DriverSlot { + val row = linuxRows.firstOrNull { it.id == linuxSelected } + val live = SessionState.runtimeDriver?.let { id -> linuxRows.firstOrNull { it.id == id }?.name } + return DriverSlot( + name = row?.name ?: activity.getString(R.string.gpu_runtime_default), + source = slotSource(linuxSelected.isEmpty(), R.string.gpu_src_default), + pending = runtimePending, + status = when { + runtimePending -> activity.getString(R.string.gpu_runtime_pending, live ?: activity.getString(R.string.gpu_previous_driver)) + sessionRunning -> activity.getString(R.string.gpu_runtime_live) + else -> activity.getString(R.string.gpu_runtime_hint) + }, + ) + } + + fun restartApp() { + if (SessionState.running) return + val launch = activity.packageManager.getLaunchIntentForPackage(activity.packageName) ?: return + activity.startActivity(android.content.Intent.makeRestartActivityTask(launch.component) + .putExtra(com.droiddeck.launcher.stores.download.StoreDownloadService.EXTRA_NAV, "components")) + Runtime.getRuntime().exit(0) + } var androidRows by mutableStateOf>(emptyList()) var androidSelected by mutableStateOf("") @@ -94,6 +160,9 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl canRestoreBundled = td.hiddenBundled().isNotEmpty() androidSelected = SessionPrefs.androidDriver(activity) activeBundle = DriverBundle.active(activity)?.label + restartPending = CompositorHost.isStarted && CompositorHost.displayChoice.let { it != null && it != androidSelected } + sessionRunning = SessionState.running + runtimePending = sessionRunning && SessionState.runtimeDriver.let { it != null && it != linuxSelected } refreshReleaseRows() refreshPairs() } @@ -101,8 +170,14 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl fun summary(): String { val active = pairRows.firstOrNull { it.active }?.name ?: activeBundle ?: if (SystemVulkanDriver.usesDefault(linuxSelected) && androidSelected == TurnipDriver.AUTO) activity.getString(R.string.gpu_system_powervr) else null - val label = activity.getString(if (mode == SessionPrefs.GPU_DRIVERS_AUTO) R.string.common_auto else R.string.drivers_manual) - return active?.let { activity.getString(R.string.drivers_summary, label, it) } ?: label + val display = displaySlot().name + val base = when { + uiMode == GPU_MODE_AUTO -> activity.getString(R.string.drivers_summary, activity.getString(R.string.common_auto), active ?: display) + uiMode == GPU_MODE_PAIR && active != null -> activity.getString(R.string.drivers_summary, activity.getString(R.string.gpu_mode_pair_short), active) + else -> activity.getString(R.string.drivers_summary, activity.getString(R.string.gpu_mode_mix_short), + runtimeSlot().name.let { if (it == display) it else activity.getString(R.string.gpu_summary_mix, display, it) }) + } + return if (restartPending) activity.getString(R.string.gpu_summary_restart, base) else base } fun refreshPairs() { @@ -137,16 +212,42 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl }.sortedByDescending { it.recommended } } - fun setMode(auto: Boolean) { - mode = if (auto) SessionPrefs.GPU_DRIVERS_AUTO else SessionPrefs.GPU_DRIVERS_MANUAL + fun chooseMode(next: String) { + pairModeOpen = next == GPU_MODE_PAIR + setMode(auto = next == GPU_MODE_AUTO, mix = next == GPU_MODE_MIX) + } + + fun setMode(auto: Boolean, mix: Boolean = false) { + mode = when { + auto -> SessionPrefs.GPU_DRIVERS_AUTO + mix -> SessionPrefs.GPU_DRIVERS_MIX + else -> SessionPrefs.GPU_DRIVERS_MANUAL + } SessionPrefs.setGpuDriverMode(activity, mode) autoStatus = "" if (auto) ensureAuto(force = false) } + fun checkOnOpen() { + if (SessionPrefs.gpuDriverMode(activity) == SessionPrefs.GPU_DRIVERS_AUTO) ensureAuto(force = false) + else if (!releaseChecking && releasesStale() && com.droiddeck.launcher.frontend.AutoComponents.isOnline(activity)) checkLatestTurnip() + } + + private fun releasesStale(): Boolean { + val cached = TurnipReleases.cached(activity) + return cached == null || System.currentTimeMillis() - cached.checkedAt > RELEASE_CHECK_INTERVAL_MS || + cached.assets.none { it.pair.isNotEmpty() } || + // A list checked before this device's open non-Adreno drivers were offered has none of them. + (!DeviceSupport.adreno() && cached.assets.none { DriverPairs.isNonAdreno(it.pair) }) + } + fun ensureAuto(force: Boolean) { mode = SessionPrefs.gpuDriverMode(activity) if (mode != SessionPrefs.GPU_DRIVERS_AUTO || pairBusy != null || releaseChecking) return + if (SessionState.running) { + if (force) autoStatus = activity.getString(R.string.drivers_auto_waits_for_session) + return + } if (gpu.family == GpuInfo.Family.POWERVR && !SystemVulkanDriver.isXclipse()) { // Auto owns both choices. Manual imports remain available when Manual is selected. SessionPrefs.ensurePowerVrAutoDrivers(activity) @@ -163,8 +264,14 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl Log.i(TAG, "auto: Mali display back on the phone's own driver (was $display)") } } - if (!force && autoCheckedThisProcess) return - autoCheckedThisProcess = true + AutoDriverTrial.rollbackDue(activity)?.let { trial -> + AutoDriverTrial.rollBack(activity, trial) + autoStatus = activity.getString(R.string.drivers_rolled_back, trial.name) + refreshDrivers() + return + } + if (!force && System.currentTimeMillis() - lastAutoCheck < RELEASE_CHECK_INTERVAL_MS) return + lastAutoCheck = System.currentTimeMillis() val displayChanged = SessionPrefs.androidDriver(activity) != QuestExperimental.defaultAndroidDriver() if (QuestExperimental.applyAutoDrivers(activity)) { autoStatus = activity.getString( @@ -181,7 +288,7 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl ui.post { gpu = GpuInfo.detect() Log.i(TAG, "auto: Mali named by its driver: ${gpu.name} -> ${gpu.family}") - autoCheckedThisProcess = false + lastAutoCheck = 0L ensureAuto(force) } }, "gpu-name").start() @@ -201,14 +308,8 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl releaseChecking = true autoStatus = activity.getString(R.string.drivers_checking_latest) Thread({ - val cached = TurnipReleases.cached(activity) - // The open non-Adreno drivers are rebuilt in place while they are tested: an hour. - val maxAge = if (DeviceSupport.adreno()) 24 * 3_600_000L else 3_600_000L - val stale = cached == null || System.currentTimeMillis() - cached.checkedAt > maxAge || - cached.assets.none { it.pair.isNotEmpty() } || - // A list checked before this device's open drivers were offered has none of them. - (!DeviceSupport.adreno() && cached.assets.none { DriverPairs.isNonAdreno(it.pair) }) - val problem = if (force || stale) runCatching { TurnipReleases.refresh(activity) }.exceptionOrNull()?.message else null + val problem = if (force || releasesStale()) runCatching { TurnipReleases.refresh(activity) }.exceptionOrNull()?.message else null + val holdBack = !force && com.droiddeck.launcher.frontend.AutoComponents.constrained(activity) ui.post { releaseChecking = false refreshReleaseRows() @@ -234,6 +335,10 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl } pair == null || !pair.complete -> autoStatus = problem?.let { activity.getString(R.string.upd_couldnt_check, it) } ?: activity.getString(R.string.drivers_recommended_unpublished) + AutoDriverTrial.release(pair) in AutoDriverTrial.bad(activity) -> + autoStatus = activity.getString(R.string.drivers_skipping_bad, pair.name, pair.version) + SessionState.running -> autoStatus = activity.getString(R.string.drivers_auto_waits_for_session) + holdBack && row?.installed != true -> autoStatus = activity.getString(R.string.drivers_auto_waits_for_network, pair.name, pair.version) else -> installPair(pair, auto = true) } } @@ -251,6 +356,8 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl fun selectPair(key: String) { if (pairBusy != null) return val pair = DriverPairs.from(TurnipReleases.cached(activity)).firstOrNull { it.key == key && it.complete } ?: return + pairModeOpen = true + if (mode != SessionPrefs.GPU_DRIVERS_MANUAL) setMode(auto = false) installPair(pair, auto = false) } @@ -268,8 +375,6 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl pairPercent = 0 if (auto) autoStatus = activity.getString(R.string.drivers_downloading_pair, pair.name, pair.version) Thread({ - val lm = LinuxVulkanDriverManager(activity) - val td = TurnipDriver(activity) var downloaded = false val result = runCatching { val zips = pair.assets @@ -287,6 +392,11 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl android.widget.Toast.makeText(activity, activity.getString(R.string.drivers_pair_updated, pair.name), android.widget.Toast.LENGTH_LONG).show() return@onSuccess } + if (auto && SessionState.running) { + lastAutoCheck = 0L + autoStatus = activity.getString(R.string.drivers_auto_waits_for_session) + return@onSuccess + } // A Mali pair under Auto: the compositor draws on the phone's own Mali driver // (dma-buf, modifiers and AHB all work there) and the guest runs the pair's // PanVK. Its Android half stays installed for a manual pick. @@ -294,24 +404,25 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl // stalls Mali gralloc ("Waiting for Steam's first frame"); it stays a manual pick // under "Runtime and display drivers separately". val displayId = if (gpu.family.mali && DriverPairs.isNonAdreno(pair.key)) TurnipDriver.AUTO else pairDisplayId - val displayChanged = SessionPrefs.androidDriver(activity) != displayId + val previousDisplay = SessionPrefs.androidDriver(activity) + val previousLinux = SessionPrefs.linuxDriver(activity) + val displayChanged = previousDisplay != displayId SessionPrefs.setAndroidDriver(activity, displayId) SessionPrefs.setLinuxDriver(activity, linuxId) // The Mali bridge switch is the user's and is left as it is: when it is on, the // bridge wins for the session (DeviceSupport.vkBridge) and the pair waits. val restart = displayChanged && CompositorHost.isStarted if (auto) { - val previous = SessionPrefs.gpuAutoInstalled(activity) - for (id in previous - setOf(displayId, linuxId)) { - val bundle = DriverBundle.containing(activity, id, lm.isInstalled(id)) - when { - bundle != null -> { DriverBundle.remove(activity, bundle); TurnipReleases.forget(activity, bundle.id) } - lm.isInstalled(id) -> lm.removeDriver(id) - else -> td.remove(id) - } - TurnipReleases.forget(activity, id) - } - SessionPrefs.setGpuAutoInstalled(activity, setOf(displayId, linuxId)) + val trial = AutoDriverTrial.current(activity) + val lastGood = trial?.let { setOf(it.previousDisplay, it.previousLinux) } ?: setOf(previousDisplay, previousLinux) + val changed = previousDisplay != displayId || previousLinux != linuxId + // A Mali pair's display is the phone's own driver (AUTO): not a download to own or prune. + SessionPrefs.setGpuAutoInstalled(activity, SessionPrefs.gpuAutoInstalled(activity) + setOf(displayId, linuxId).filter { it.isNotEmpty() && it != TurnipDriver.AUTO }) + if (changed) AutoDriverTrial.begin( + activity, AutoDriverTrial.release(pair), "${pair.name} ${pair.version}", displayId, linuxId, + trial?.previousDisplay ?: previousDisplay, trial?.previousLinux ?: previousLinux, + ) + if (!SessionState.running) AutoDriverTrial.prune(activity, lastGood + setOf(displayId, linuxId)) autoStatus = activity.getString( if (downloaded) { if (restart) R.string.drivers_updated_to_restart else R.string.drivers_updated_to } else { if (restart) R.string.drivers_switched_to_restart else R.string.drivers_switched_to }, @@ -405,14 +516,15 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl linux -> SessionPrefs.setLinuxDriver(activity, id) else -> SessionPrefs.setAndroidDriver(activity, id) } - setMode(false) + pairModeOpen = false + setMode(auto = false, mix = true) refreshDrivers() } private fun useBundle(bundle: DriverBundle.Bundle): String { val displayChanged = SessionPrefs.androidDriver(activity) != bundle.androidId DriverBundle.select(activity, bundle) - if (mode == SessionPrefs.GPU_DRIVERS_AUTO) setMode(false) + if (mode == SessionPrefs.GPU_DRIVERS_AUTO) setMode(auto = false, mix = true) return activity.getString( if (displayChanged && CompositorHost.isStarted) R.string.drivers_using_bundle_restart else R.string.drivers_using_bundle, bundle.label, @@ -521,6 +633,7 @@ internal class DriverMenus(private val activity: Activity, private val ui: Handl private companion object { const val TAG = "MainActivity" + const val RELEASE_CHECK_INTERVAL_MS = 3_600_000L } } diff --git a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt index ac7b7eb409..349fde9794 100644 --- a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt @@ -47,6 +47,7 @@ import com.droiddeck.launcher.session.SessionLogShare import com.droiddeck.launcher.session.SessionPrefs import com.droiddeck.launcher.session.SteamRepair import com.droiddeck.launcher.core.CpuCores +import com.droiddeck.launcher.core.DownloadSource import com.droiddeck.launcher.core.PhantomProcessLimit import com.droiddeck.launcher.core.PhantomProcessStatus import com.droiddeck.launcher.core.WirelessAdbFix @@ -108,6 +109,10 @@ class MainActivity : ComponentActivity() { private var frameGenLabel by mutableStateOf("") private var lossless by mutableStateOf(Lossless.State.NONE) private var showRemove by mutableStateOf(false) + private var pendingSwitch by mutableStateOf(null) + private var switchingTo: Intent? = null + private var switchPoll: Runnable? = null + private var switchDeadline = 0L private var showResetSettings by mutableStateOf(false) private var lowSpace by mutableStateOf(null) private var showNonAdreno by mutableStateOf(null) @@ -159,6 +164,9 @@ class MainActivity : ComponentActivity() { private var stretch16x9 by mutableStateOf(false) private var orientation by mutableStateOf(android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE) private var launcherFullscreen by mutableStateOf(true) + private var downloadSource by mutableStateOf(DownloadSource.MODE_AUTO) + private var downloadMirror by mutableStateOf("") + private var downloadPrefix by mutableStateOf("") private var animationsEnabled by mutableStateOf(true) private var gameStoresEnabled by mutableStateOf(true) private var gameStoresSpeedTier by mutableStateOf("fast") @@ -192,6 +200,10 @@ class MainActivity : ComponentActivity() { SessionPrefs.setWifiDiscoveryEnabled(this, WifiDiscovery.permissionGranted(this)) refreshWifiDiscovery() } + private val cameraPermission = registerForActivityResult(ActivityResultContracts.RequestPermission()) { + com.droiddeck.launcher.handtracking.HandTracking.refreshPermission(this) + } + private var placementCheck by mutableStateOf(null) private val wifiPermissionSettings = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { SessionPrefs.setWifiDiscoveryEnabled(this, WifiDiscovery.permissionGranted(this)) refreshWifiDiscovery() @@ -209,6 +221,9 @@ class MainActivity : ComponentActivity() { private val pickDeckyPluginZip = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r -> if (r.resultCode == RESULT_OK) InAppFilePicker.pickedFile(r.data)?.let { decky.importPluginZip(it) } } + private val pickBootMovie = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r -> + if (r.resultCode == RESULT_OK) InAppFilePicker.pickedFile(r.data)?.let { importBootMovie(it) } + } private val pickAnyDriver = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r -> if (r.resultCode == RESULT_OK) InAppFilePicker.pickedUri(r.data)?.let { drivers.importDriver(it, linux = null) } } @@ -253,6 +268,38 @@ class MainActivity : ComponentActivity() { }, "lossless-sync").start() } + private fun importBootMovie(file: File) { + bootMovieImporting = true + bootMovieProgress = -1 + Thread({ + val result = com.droiddeck.launcher.session.BootMovie.import( + this, file, + onStart = { ui.post { android.widget.Toast.makeText(this, getString(R.string.boot_movie_converting_started, file.name), android.widget.Toast.LENGTH_LONG).show() } }, + onProgress = { percent -> ui.post { bootMovieProgress = percent } }, + ) + val message = when (result) { + is com.droiddeck.launcher.session.BootMovie.Import.Done -> getString( + if (result.audioDropped) R.string.boot_movie_imported_silent else R.string.boot_movie_imported, result.name) + com.droiddeck.launcher.session.BootMovie.Import.TooLong -> + getString(R.string.boot_movie_too_long, com.droiddeck.launcher.session.BootMovie.MAX_CONVERT_SECONDS) + is com.droiddeck.launcher.session.BootMovie.Import.Unsupported -> getString(R.string.boot_movie_unsupported) + com.droiddeck.launcher.session.BootMovie.Import.Failed -> getString(R.string.boot_movie_import_failed) + } + ui.post { + bootMovieImporting = false + bootMovieProgress = -1 + loadBootMovie() + android.widget.Toast.makeText(this, message, android.widget.Toast.LENGTH_LONG).show() + } + }, "boot-movie-import").start() + } + + private fun loadBootMovie() { + bootMovie = com.droiddeck.launcher.session.BootMovie.choice(this) + bootMovieSound = SessionPrefs.bootMovieSound(this) + bootMovieCustomName = com.droiddeck.launcher.session.BootMovie.customName(this) + } + private fun importLossless(dll: File) { Thread({ val message = Lossless.message(this, Lossless.import(this, dll)) @@ -328,7 +375,13 @@ class MainActivity : ComponentActivity() { private var resolution by mutableStateOf(com.droiddeck.launcher.session.SessionDisplay.DEFAULT_RESOLUTION) private var fexPreset by mutableStateOf("") private var forceSsbs by mutableStateOf(false) + private var steamClientArch by mutableStateOf("arm64") private var runSteamAtStartup by mutableStateOf(false) + private var bootMovie by mutableStateOf(com.droiddeck.launcher.session.BootMovie.DROIDDECK_30) + private var bootMovieSound by mutableStateOf(true) + private var bootMovieCustomName by mutableStateOf(null) + private var bootMovieImporting by mutableStateOf(false) + private var bootMovieProgress by mutableStateOf(-1) private var theme by mutableStateOf("graphite") private var appScale by mutableStateOf(com.droiddeck.launcher.core.AppUiPrefs.DEFAULT_SCALE) private var hdrOn by mutableStateOf(false) @@ -351,11 +404,13 @@ class MainActivity : ComponentActivity() { } private var romsDir by mutableStateOf(null) private var steamGames by mutableStateOf>(emptyList()) + private var steamGamesX64 by mutableStateOf(false) @Volatile private var componentSweepDone = false @Volatile private var componentSweepSession: String? = null private var emulatorList by mutableStateOf>(emptyList()) private var runningLabel by mutableStateOf(null) private var logsEnabled by mutableStateOf(true) + private var vacDiagnostics by mutableStateOf(false) private var agentCommands by mutableStateOf(false) private var graphicsLogs by mutableStateOf(false) private var steamGpuDrawing by mutableStateOf(false) @@ -466,24 +521,186 @@ class MainActivity : ComponentActivity() { android.widget.Toast.makeText(this, R.string.main_wait_install_game, android.widget.Toast.LENGTH_SHORT).show() return false } + if (com.droiddeck.launcher.session.NoSteamLaunch.enabled(this, game)) return launchWithoutSteam(game, returnHome) if (SessionState.running) { if (SessionState.mode != SessionService.MODE_STEAM || SessionState.stopRequested) { android.widget.Toast.makeText(this, R.string.game_link_session_busy, android.widget.Toast.LENGTH_LONG).show() return true } - if (!SessionService.launchGame(this, game.gameIdString)) { + val steamVr = game.gameIdString == com.droiddeck.launcher.gpu.SteamVr.APP_ID + if (!steamVr && !SessionService.launchGame(this, game.gameIdString)) { android.widget.Toast.makeText(this, R.string.game_link_failed, android.widget.Toast.LENGTH_LONG).show() return false } startActivity(Intent(this, SessionActivity::class.java).setAction(SessionService.ACTION_RESUME) + .putExtra(SessionActivity.EXTRA_STEAMVR, steamVr) .putExtra(SessionActivity.EXTRA_RETURN_HOME, returnHome) .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)) return true } return startSession(Intent(this, SessionActivity::class.java) .putExtra(SessionActivity.EXTRA_RETURN_HOME, returnHome) - .putExtra(SessionService.EXTRA_STEAM_URL, - com.droiddeck.launcher.frontend.GameLaunchLink.steamUrl(game.gameIdString)), steamSession = true) + .apply { + if (game.gameIdString == com.droiddeck.launcher.gpu.SteamVr.APP_ID) { + putExtra(SessionActivity.EXTRA_STEAMVR, true) + } else { + putExtra(SessionService.EXTRA_STEAM_URL, + com.droiddeck.launcher.frontend.GameLaunchLink.steamUrl(game.gameIdString)) + } + }, steamSession = true) + } + + private fun launchWithoutSteam(game: Library.SteamGame, returnHome: Boolean): Boolean { + val app = applicationContext + Thread({ + val added = if (game.library == Library.ADDED) runCatching { com.droiddeck.launcher.session.NoSteamLaunch.addedGame(app, game) }.getOrNull() else null + val command = com.droiddeck.launcher.session.NoSteamLaunch.command(game, added) + ui.post { + if (isDestroyed) return@post + if (command == null) { + android.widget.Toast.makeText(this, R.string.game_link_failed, android.widget.Toast.LENGTH_LONG).show() + return@post + } + com.droiddeck.launcher.session.NoSteamLaunch.remember(command) + val next = Intent(this, SessionActivity::class.java) + .putExtra(SessionActivity.EXTRA_RETURN_HOME, returnHome) + .putExtra(SessionService.EXTRA_MODE, SessionService.MODE_RUN) + .putExtra(SessionService.EXTRA_PROGRAM, command.program) + .putExtra(SessionService.EXTRA_PROGRAM_ARGS, command.args.toTypedArray()) + when { + !SessionState.running -> startSessionOrWait(next) + SessionState.stopRequested -> android.widget.Toast.makeText(this, R.string.game_link_session_busy, android.widget.Toast.LENGTH_LONG).show() + SessionState.mode == SessionService.MODE_RUN && SessionState.program == command.program && SessionState.programArgs == command.args -> + startActivity(Intent(this, SessionActivity::class.java).setAction(SessionService.ACTION_RESUME) + .putExtra(SessionActivity.EXTRA_RETURN_HOME, returnHome) + .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)) + else -> pendingSwitch = next + } + } + }, "no-steam-launch").start() + return true + } + + private fun opensEpicLauncher(next: Intent): Boolean = + next.getStringExtra(SessionService.EXTRA_PROGRAM) == com.droiddeck.launcher.session.NoSteamLaunch.EPIC || + next.getStringExtra(SessionService.EXTRA_STEAM_URL) == com.droiddeck.launcher.frontend.GameLaunchLink.steamUrl( + com.droiddeck.launcher.stores.epic.EpicClient.gameId(com.droiddeck.launcher.stores.epic.EpicClient.shortcutAppId)) + + private fun uninstallEpicLauncher() { + if (com.droiddeck.launcher.stores.epic.EpicClient.uninstalling) return + com.droiddeck.launcher.stores.epic.EpicClient.uninstalling = true + pendingSwitch?.takeIf(::opensEpicLauncher)?.let { pendingSwitch = null } + switchingTo?.takeIf(::opensEpicLauncher)?.let { + switchPoll?.let { poll -> ui.removeCallbacks(poll) } + switchPoll = null + switchingTo = null + } + if (SessionState.running) SessionService.stop(this) + val app = applicationContext + val deadline = android.os.SystemClock.uptimeMillis() + SESSION_SWITCH_WAIT_MS + Thread({ + while ((SessionState.running || SessionState.phase !in SESSION_ENDED) && android.os.SystemClock.uptimeMillis() < deadline) { + Thread.sleep(SESSION_SWITCH_POLL_MS) + } + val ended = !SessionState.running && SessionState.phase in SESSION_ENDED + val done = try { + ended && com.droiddeck.launcher.stores.epic.EpicClient.uninstall(app) + } finally { + com.droiddeck.launcher.stores.epic.EpicClient.uninstalling = false + } + ui.post { + if (!isDestroyed) refresh() + android.widget.Toast.makeText(app, if (done) R.string.epic_client_uninstalled else R.string.epic_client_uninstall_failed, + android.widget.Toast.LENGTH_LONG).show() + } + }, "epic-uninstall").start() + } + + private fun openEpicLauncher(): Boolean { + if (com.droiddeck.launcher.stores.epic.EpicClient.uninstalling) { + android.widget.Toast.makeText(this, R.string.epic_client_uninstalling, android.widget.Toast.LENGTH_SHORT).show() + return false + } + if (protons.protonBusyId != null || ProtonExtras.installInProgress || pkgStage != null) { + android.widget.Toast.makeText(this, R.string.main_wait_install_game, android.widget.Toast.LENGTH_SHORT).show() + return false + } + if (!com.droiddeck.launcher.stores.epic.EpicClient.launcherRunning(this) && !com.droiddeck.launcher.stores.epic.EpicClient.fexReady(this)) { + com.droiddeck.launcher.stores.epic.EpicClient.requestFex(this) + android.widget.Toast.makeText(this, R.string.epic_client_needs_fex, android.widget.Toast.LENGTH_LONG).show() + if (!SessionState.running) startSteamSession() + else if (SessionState.mode == SessionService.MODE_STEAM) startActivity(Intent(this, SessionActivity::class.java) + .setAction(SessionService.ACTION_RESUME).addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)) + return true + } + if (com.droiddeck.launcher.session.NoSteamLaunch.enabled(this, com.droiddeck.launcher.stores.epic.EpicClient.shortcutAppId)) { + com.droiddeck.launcher.stores.epic.EpicClient.launcherEntry(this, Library.EPIC_LAUNCHER_NAME)?.let { return launchWithoutSteam(it, false) } + } + val launcher = Intent(this, SessionActivity::class.java) + .putExtra(SessionActivity.EXTRA_RETURN_HOME, false) + .putExtra(SessionService.EXTRA_STEAM_URL, com.droiddeck.launcher.frontend.GameLaunchLink.steamUrl( + com.droiddeck.launcher.stores.epic.EpicClient.gameId(com.droiddeck.launcher.stores.epic.EpicClient.shortcutAppId))) + if (SessionState.running && SessionState.mode == SessionService.MODE_STEAM && !SessionState.stopRequested) { + val app = applicationContext + val shortcut = com.droiddeck.launcher.stores.epic.EpicClient.shortcutAppId + val listed = com.droiddeck.launcher.frontend.AddedGames.inSteam(app, shortcut) + if (listed && !SessionService.launchGame(this, com.droiddeck.launcher.stores.epic.EpicClient.gameId(shortcut))) { + android.widget.Toast.makeText(this, R.string.game_link_failed, android.widget.Toast.LENGTH_LONG).show() + return false + } + startActivity(Intent(this, SessionActivity::class.java).setAction(SessionService.ACTION_RESUME) + .putExtra(SessionActivity.EXTRA_RETURN_HOME, false) + .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)) + if (!listed) Thread({ + com.droiddeck.launcher.frontend.AddedGamesPublisher.republish(app) + val id = com.droiddeck.launcher.stores.epic.EpicClient.steamLauncherId(app) ?: shortcut + ui.post { SessionService.launchGame(app, com.droiddeck.launcher.stores.epic.EpicClient.gameId(id)) } + }, "epic-launcher-open").start() + return true + } + if (SessionState.running) { + if (SessionState.stopRequested) android.widget.Toast.makeText(this, R.string.game_link_session_busy, android.widget.Toast.LENGTH_LONG).show() + else pendingSwitch = launcher + return true + } + return startSessionOrWait(launcher) + } + + private fun startSessionOrWait(next: Intent): Boolean { + val started = startSession(next, steamSession = next.hasExtra(SessionService.EXTRA_STEAM_URL)) + if (!started && (busy || LinuxRuntimeInstaller.isBusy())) android.widget.Toast.makeText(this, R.string.main_wait_install_game, android.widget.Toast.LENGTH_SHORT).show() + return started + } + + private fun startAfterSession(next: Intent) { + SessionService.stop(this) + awaitSessionEnd(next, android.os.SystemClock.uptimeMillis() + SESSION_SWITCH_WAIT_MS) + } + + private fun awaitSessionEnd(next: Intent, deadline: Long) { + switchingTo = next + switchDeadline = deadline + switchPoll?.let { ui.removeCallbacks(it) } + val poll = object : Runnable { + override fun run() { + if (isDestroyed) return + if (SessionState.running || SessionState.phase !in SESSION_ENDED) { + if (android.os.SystemClock.uptimeMillis() < deadline) ui.postDelayed(this, SESSION_SWITCH_POLL_MS) + else { + switchPoll = null + switchingTo = null + android.widget.Toast.makeText(this@MainActivity, R.string.game_link_session_busy, android.widget.Toast.LENGTH_LONG).show() + } + return + } + switchPoll = null + switchingTo = null + if (com.droiddeck.launcher.stores.epic.EpicClient.uninstalling && opensEpicLauncher(next)) return + startSessionOrWait(next) + } + } + switchPoll = poll + ui.postDelayed(poll, SESSION_SWITCH_POLL_MS) } private fun handleGameLink(games: List) { @@ -518,11 +735,17 @@ class MainActivity : ComponentActivity() { theme = SessionPrefs.theme(this) frameGenLabel = getString(R.string.frame_gen_off) appScale = com.droiddeck.launcher.core.AppUiPrefs.scale(this) - steamGames = if (shortcutPicker) emptyList() else com.droiddeck.launcher.frontend.LibraryCache.load(this) + val (cached, cachedX64) = com.droiddeck.launcher.frontend.LibraryCache.snapshot(this) + steamGames = if (shortcutPicker) emptyList() else cached + steamGamesX64 = cachedX64 backActionsInverted = SessionPrefs.backActionsInverted(this) orientation = SessionPrefs.orientation(this) requestedOrientation = orientation launcherFullscreen = SessionPrefs.launcherFullscreen(this) + downloadSource = DownloadSource.mode(this) + downloadMirror = DownloadSource.mirror(this) + downloadPrefix = DownloadSource.custom(this) + DownloadSource.probe() animationsEnabled = SessionPrefs.animationsEnabled(this) gameStoresEnabled = SessionPrefs.gameStoresEnabled(this) gameStoresSpeedTier = SessionPrefs.gameStoresSpeedTier(this) @@ -552,8 +775,10 @@ class MainActivity : ComponentActivity() { busy = busy, stage = stage, percent = percent, desktopInstalled = desktopInstalled, desktopPresent = desktopPresent, offlineAccount = offlineAccount, offline = offline, - frameGenLabel = frameGenLabel, romsDir = romsDir, logsEnabled = logsEnabled, agentCommands = agentCommands, graphicsLogs = graphicsLogs, steamGpuDrawing = steamGpuDrawing, bridgeFellBack = bridgeFellBack, bridgeFellBackMemory = bridgeFellBackMemory, - steamGames = steamGames, emulators = emulatorList, running = runningLabel, + frameGenLabel = frameGenLabel, romsDir = romsDir, logsEnabled = logsEnabled, + vacDiagnostics = vacDiagnostics, agentCommands = agentCommands, + graphicsLogs = graphicsLogs, steamGpuDrawing = steamGpuDrawing, bridgeFellBack = bridgeFellBack, bridgeFellBackMemory = bridgeFellBackMemory, + steamGames = steamGames, steamGamesX64 = steamGamesX64, emulators = emulatorList, running = runningLabel, frameGen = FrameGen.mode(this), lossless = lossless, pageKey = if (showPerformance) "performance" else if (showComponents) "components" else if (showMapping) "controller-mapping" else null, @@ -580,6 +805,9 @@ class MainActivity : ComponentActivity() { showPhantomGate = showPhantomGate, orientation = orientation, launcherFullscreen = launcherFullscreen, + downloadSource = downloadSource, + downloadMirror = downloadMirror, + downloadPrefix = downloadPrefix, animationsEnabled = animationsEnabled, gameStoresEnabled = gameStoresEnabled, gameStoresSpeedTier = gameStoresSpeedTier, @@ -594,6 +822,7 @@ class MainActivity : ComponentActivity() { ), FrontEndActions( onPlay = { playSteam() }, + onPlaySteamVr = { playSteamVr() }, onSteamUrl = { url -> if (!SessionState.running) startSession( Intent(this, SessionActivity::class.java).putExtra(SessionService.EXTRA_STEAM_URL, url), steamSession = true, @@ -611,6 +840,8 @@ class MainActivity : ComponentActivity() { com.droiddeck.launcher.stores.StoreLaunch.prepare(this, g) { launchGame(g) } } }, + onEpicLauncher = { openEpicLauncher() }, + onUninstallEpicLauncher = { uninstallEpicLauncher() }, onGameShortcut = { g -> com.droiddeck.launcher.frontend.GameShortcuts.pin(this, g) }, onExportGameFile = { g -> pickGameExport(g) }, onSyncGameFiles = { pickGameExport(null) }, @@ -619,6 +850,7 @@ class MainActivity : ComponentActivity() { val known = steamGames.mapNotNull { it.gameFiles?.path }.toSet() updateAddedGames(folders, then = { if (folders.any { it !in known }) fetchAddedGameArt() }) }, + onSteamGameArtChanged = { appId -> refreshSteamGameArt(appId) }, onAddedGameRemoved = { folder, appId, name -> removeAddedGame(folder, appId, name) }, onAddedGamesArt = { on -> SessionPrefs.setAddedGamesArt(this, on); addedGamesArt = on; if (on) refreshAddedGames() }, onSgdbKey = { key -> @@ -712,6 +944,10 @@ class MainActivity : ComponentActivity() { SessionPrefs.setDetailedGraphicsLogs(this, !SessionPrefs.detailedGraphicsLogs(this)) graphicsLogs = SessionPrefs.detailedGraphicsLogs(this) }, + onVacDiagnostics = { + SessionPrefs.setVacDiagnostics(this, !SessionPrefs.vacDiagnostics(this)) + vacDiagnostics = SessionPrefs.vacDiagnostics(this) + }, onAgentCommands = { com.droiddeck.launcher.agent.AgentAccess.setCommandsEnabled(this, !com.droiddeck.launcher.agent.AgentAccess.commandsEnabled(this)) agentCommands = com.droiddeck.launcher.agent.AgentAccess.commandsEnabled(this) @@ -775,6 +1011,18 @@ class MainActivity : ComponentActivity() { animationsEnabled = on com.droiddeck.launcher.ui.Motion.refresh(this) }, + onDownloadSource = { mode -> + DownloadSource.setMode(this, mode) + downloadSource = mode + }, + onDownloadMirror = { host -> + DownloadSource.setMirror(this, host) + downloadMirror = host + }, + onDownloadPrefix = { prefix -> + DownloadSource.setCustom(this, prefix) + downloadPrefix = DownloadSource.custom(this) + }, onHomeApp = { manageHomeApp() }, onHomeScreen = { on -> HomeApp.setHomeScreenEnabled(this, on) @@ -848,6 +1096,7 @@ class MainActivity : ComponentActivity() { onQamButton = { on -> ControllerPrefs.setQamButton(this, on); refreshController() }, onKeyboardButton = { on -> ControllerPrefs.setKeyboardButton(this, on); refreshController() }, onSelectSteam = { on -> ControllerPrefs.setSelectSteam(this, on); refreshController() }, + onJoyConVr = { on -> ControllerPrefs.setJoyConVr(this, on); refreshController() }, onEditLayout = { startActivity(Intent(this, ControllerEditorActivity::class.java)) }, onResetLayout = { ControllerPrefs.resetAllLayouts(this); refreshController() }, onMapping = { showPerformance = false; showComponents = false; showMapping = true }, @@ -875,6 +1124,15 @@ class MainActivity : ComponentActivity() { onDismiss = { showNonAdreno = null }, ) } + pendingSwitch?.let { next -> + ConfirmDialog( + title = androidx.compose.ui.res.stringResource(R.string.drawer_stop_title), + text = runningLabel ?: "", + confirm = androidx.compose.ui.res.stringResource(R.string.drawer_stop), + onConfirm = { pendingSwitch = null; startAfterSession(next) }, + onDismiss = { pendingSwitch = null }, + ) + } if (showRemove) ConfirmDialog( title = androidx.compose.ui.res.stringResource(R.string.main_remove_runtime_title), text = androidx.compose.ui.res.stringResource(R.string.main_remove_runtime_text), @@ -890,6 +1148,12 @@ class MainActivity : ComponentActivity() { onDismiss = { lowSpace = null }, ) } + com.droiddeck.launcher.ui.HandCameraHost( + check = placementCheck, + onAskPermission = { cameraPermission.launch(Manifest.permission.CAMERA) }, + onPlay = { placementCheck = null; startSteamSession(steamVr = true) }, + onClose = { placementCheck = null }, + ) if (showResetSettings) com.droiddeck.launcher.ui.ResetSettingsDialog( onConfirm = { gameProfiles -> resetSettings(gameProfiles) }, onDismiss = { showResetSettings = false }, @@ -907,6 +1171,10 @@ class MainActivity : ComponentActivity() { } if (savedInstanceState == null) ui.post { startSteamAtStartupIfEnabled() } + else { + pendingSwitch = savedIntent(savedInstanceState, KEY_PENDING_SWITCH) + savedIntent(savedInstanceState, KEY_SWITCHING_TO)?.let { awaitSessionEnd(it, savedInstanceState.getLong(KEY_SWITCH_DEADLINE)) } + } val wanted = ArrayList() if (checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) { @@ -950,8 +1218,15 @@ class MainActivity : ComponentActivity() { } else startSteamSession() } - private fun startSteamSession() { - startSession(Intent(this, SessionActivity::class.java), steamSession = true) + private fun playSteamVr() { + val tracking = com.droiddeck.launcher.glasses.Glasses.settings.value + if (!com.droiddeck.launcher.glasses.Glasses.state.value.usesSpatialControllers(tracking) && + com.droiddeck.launcher.handtracking.HandTracking.wanted(this)) placementCheck = true + else startSteamSession(steamVr = true) + } + + private fun startSteamSession(steamVr: Boolean = false) { + startSession(Intent(this, SessionActivity::class.java).putExtra(SessionActivity.EXTRA_STEAMVR, steamVr), steamSession = true) } override fun onWindowFocusChanged(hasFocus: Boolean) { @@ -1013,7 +1288,7 @@ class MainActivity : ComponentActivity() { refreshPhantomStatus() syncLossless() updates.onResume() - drivers.ensureAuto(force = false) + drivers.checkOnOpen() protons.checkUpdates() if (!SessionState.running) Thread({ val applied = runCatching { ComponentsManager.applyQueued(this) }.getOrDefault(emptyList()) @@ -1048,6 +1323,19 @@ class MainActivity : ComponentActivity() { refreshSecondScreenDisplays() } + override fun onSaveInstanceState(outState: Bundle) { + super.onSaveInstanceState(outState) + pendingSwitch?.let { outState.putParcelable(KEY_PENDING_SWITCH, it) } + switchingTo?.let { + outState.putParcelable(KEY_SWITCHING_TO, it) + outState.putLong(KEY_SWITCH_DEADLINE, switchDeadline) + } + } + + private fun savedIntent(state: Bundle, key: String): Intent? = + if (Build.VERSION.SDK_INT >= 33) state.getParcelable(key, Intent::class.java) + else @Suppress("DEPRECATION") state.getParcelable(key) + override fun onDestroy() { updates.unregister() super.onDestroy() @@ -1075,7 +1363,9 @@ class MainActivity : ComponentActivity() { private fun refreshSecondScreenDisplays() { if (!::displayManager.isInitialized) return - secondScreenDisplays = SecondScreenDisplays.available(displayManager) + // The launcher can itself be shown on a non-default display (DeX, an external monitor); that one is not a "second screen". + val ownDisplayId = if (android.os.Build.VERSION.SDK_INT >= 30) display?.displayId ?: android.view.Display.DEFAULT_DISPLAY else @Suppress("DEPRECATION") windowManager.defaultDisplay.displayId + secondScreenDisplays = SecondScreenDisplays.available(displayManager, ownDisplayId) } private fun launchAndroidApp(app: HomeApp.LaunchableApp, displayId: Int?) { @@ -1210,6 +1500,8 @@ class MainActivity : ComponentActivity() { onImportAndroid = { pickAndroidDriver.launch(InAppFilePicker.buildIntent(this, ZIP_EXT, getString(R.string.drivers_pick_android))) }, onImportZip = { pickAnyDriver.launch(InAppFilePicker.buildIntent(this, ZIP_EXT, getString(R.string.drivers_pick_any))) }, onRestoreBundled = { TurnipDriver(this).restoreBundled(); drivers.refreshDrivers() }, + onMode = { m -> drivers.chooseMode(m) }, + onRestart = { drivers.restartApp() }, ), protons = com.droiddeck.launcher.ui.ProtonsState( rows = protons.protonRows, busyId = protons.protonBusyId, stage = protons.protonStage, percent = protons.protonPercent, @@ -1313,10 +1605,16 @@ class MainActivity : ComponentActivity() { fexPreset = if (mode == SessionService.MODE_STEAM) fexPreset else null, forceSsbs = forceSsbs, syncBackend = if (mode == SessionService.MODE_STEAM) SessionPrefs.syncBackendOf(fastSync, fsyncFirst, syncFallback) else null, + steamClientArch = if (mode == SessionService.MODE_STEAM) steamClientArch else null, steamRepairQueued = steamRepairQueued, mangoapp = mangoapp, steamController = if (mode == SessionService.MODE_STEAM) steamController else null, runSteamAtStartup = mode == SessionService.MODE_STEAM && runSteamAtStartup, + bootMovie = if (mode == SessionService.MODE_STEAM) bootMovie else null, + bootMovieSound = bootMovieSound, + bootMovieCustomName = bootMovieCustomName, + bootMovieImporting = bootMovieImporting, + bootMovieProgress = bootMovieProgress, wifiDiscovery = if (mode == SessionService.MODE_STEAM) wifiDiscovery else null, wifiDiscoveryPermission = wifiDiscoveryPermission, wifiDiscoveryLocation = wifiDiscoveryLocation, @@ -1391,12 +1689,19 @@ class MainActivity : ComponentActivity() { syncFallback = SessionPrefs.syncFallback(this) }, onSteamRepair = { steamRepairQueued = SteamRepair.queue(this) }, + onSteamClientArch = { id -> SessionPrefs.setSteamClientArch(this, id); steamClientArch = id; refresh() }, onMangoapp = { on -> SessionPrefs.setMangoapp(this, on); mangoapp = on }, onSteamController = { id -> SessionPrefs.setSteamController(this, id); steamController = id }, onRunSteamAtStartup = { on -> SessionPrefs.setRunSteamAtStartup(this, on) runSteamAtStartup = on }, + onBootMovie = { id -> SessionPrefs.setBootMovie(this, id); loadBootMovie() }, + onBootMovieSound = { on -> SessionPrefs.setBootMovieSound(this, on); bootMovieSound = on }, + onImportBootMovie = { + pickBootMovie.launch(InAppFilePicker.buildIntent(this, com.droiddeck.launcher.session.BootMovie.PICKER_EXTENSIONS, getString(R.string.boot_movie_pick))) + }, + onRemoveBootMovie = { com.droiddeck.launcher.session.BootMovie.removeCustom(this); loadBootMovie() }, onDeckyInstall = { release -> decky.installDecky(release) }, onDeckyCheck = { decky.refreshDecky() }, onDeckyEnabled = { enabled -> DeckyManager.setSupervisorEnabled(this, enabled); decky.deckySupervisor = enabled }, @@ -1467,6 +1772,20 @@ class MainActivity : ComponentActivity() { }, "added-games-update").start() } + private val steamArtRefreshes = HashMap() + + private fun refreshSteamGameArt(appId: Int) { + val version = (steamArtRefreshes[appId] ?: 0) + 1 + steamArtRefreshes[appId] = version + Thread({ + val fresh = com.droiddeck.launcher.frontend.Library.steamGames(this).firstOrNull { it.appId == appId } ?: return@Thread + ui.post { + if (steamArtRefreshes[appId] != version) return@post + steamGames = steamGames.map { if (it.appId == appId && it.library != Library.ADDED) fresh else it } + } + }, "steam-art-update").start() + } + private fun removeAddedGame(folder: String, appId: Long?, name: String) { steamGames = steamGames.filterNot { it.library == Library.ADDED && it.gameFiles?.path == folder } Thread({ com.droiddeck.launcher.frontend.AddedGames.remove(this, java.io.File(folder), appId, name) }, "added-game-remove").start() @@ -1510,10 +1829,12 @@ class MainActivity : ComponentActivity() { fastSync = SessionPrefs.fastSync(this) fsyncFirst = SessionPrefs.fsyncFirst(this) syncFallback = SessionPrefs.syncFallback(this) + steamClientArch = SessionPrefs.steamClientArch(this) steamRepairQueued = SteamRepair.queued(this) mangoapp = SessionPrefs.mangoapp(this) steamController = SessionPrefs.steamController(this) runSteamAtStartup = SessionPrefs.runSteamAtStartup(this) + loadBootMovie() hdrOn = SessionPrefs.hdr(this, mode) fpsLimit = SessionPrefs.fpsLimit(this, mode) upscaler = SessionPrefs.upscaler(this) @@ -1588,7 +1909,14 @@ class MainActivity : ComponentActivity() { } private fun refresh() { + // Until the scan finishes, the other client's games would launch in this one. + val listX64 = SessionPrefs.activeSteamClientArch(this) == "x86_64" + if (listX64 != steamGamesX64) { + steamGamesX64 = listX64 + steamGames = steamGames.filterNot(Library::fromSteamClient) + } if (!busy && LinuxRuntimeInstaller.isBusy()) followRuntimeOperation { LinuxRuntimeInstaller.attach(it) } + if (showComponents) drivers.refreshDrivers() addedGamesArt = SessionPrefs.addedGamesArt(this) desktopInstalled = DesktopCatalog.desktopInstalled(this) desktopPresent = DesktopCatalog.desktopPresent(this) @@ -1600,6 +1928,7 @@ class MainActivity : ComponentActivity() { frameGenLabel = FrameGen.label(this) romsDir = SessionPrefs.romsDir(this).takeIf { it.isNotEmpty() } logsEnabled = SessionPrefs.logsEnabled(this) + vacDiagnostics = SessionPrefs.vacDiagnostics(this) agentCommands = com.droiddeck.launcher.agent.AgentAccess.commandsEnabled(this) graphicsLogs = SessionPrefs.detailedGraphicsLogs(this) steamGpuDrawing = SessionPrefs.steamGpuCompositing(this) @@ -1612,7 +1941,11 @@ class MainActivity : ComponentActivity() { else -> "Steam" } else null val scanGeneration = ++libraryScanGeneration + val artRefreshesAtStart = HashMap(steamArtRefreshes) if (shortcutPicker) shortcutLibraryScanning = true + if (SessionPrefs.steamClientArch(this) == "x86_64" && !OfflineMode.enabled(this)) { + Thread({ com.droiddeck.launcher.session.FexCatalog.refresh(this) }, "fex-catalog").start() + } Thread({ val emus = Library.emulators(this) { id -> DesktopCatalog.installed(this, id) != null } ui.post { if (scanGeneration == libraryScanGeneration) emulatorList = emus } @@ -1629,9 +1962,11 @@ class MainActivity : ComponentActivity() { } } } - val games = if (ready) Library.launchableGames(this) else emptyList() + val scannedArch = SessionPrefs.activeSteamClientArch(this) + val scannedX64 = scannedArch == "x86_64" + val games = if (ready) Library.launchableGames(this, arch = scannedArch) else emptyList() val all = games.distinctBy { it.gameId } - if (ready) com.droiddeck.launcher.frontend.LibraryCache.save(this, all) + if (ready && scanGeneration == libraryScanGeneration) com.droiddeck.launcher.frontend.LibraryCache.save(this, all, scannedX64) val endedSession = SessionState.sessionId.takeIf { !SessionState.running && it != null && it != componentSweepSession } if (ready && (!componentSweepDone || endedSession != null)) { componentSweepDone = true @@ -1640,7 +1975,12 @@ class MainActivity : ComponentActivity() { } ui.post { if (scanGeneration == libraryScanGeneration) { - steamGames = all + val current = steamGames.filter { it.library != Library.ADDED }.associateBy { it.appId } + steamGamesX64 = scannedX64 + steamGames = all.map { g -> + val newer = current[g.appId] + if (newer != null && g.library != Library.ADDED && steamArtRefreshes[g.appId] != artRefreshesAtStart[g.appId]) g.withArt(newer.art, newer.hero, newer.icon) else g + } shortcutLibraryScanning = false handleGameLink(all) } @@ -1789,6 +2129,12 @@ class MainActivity : ComponentActivity() { companion object { private const val TAG = "MainActivity" private const val MEDIA_SETTLE_MS = 1500L + private const val SESSION_SWITCH_WAIT_MS = 30_000L + private const val SESSION_SWITCH_POLL_MS = 250L + private const val KEY_PENDING_SWITCH = "pending_switch" + private const val KEY_SWITCHING_TO = "switching_to" + private const val KEY_SWITCH_DEADLINE = "switch_deadline" + private val SESSION_ENDED = setOf(SessionPhase.IDLE, SessionPhase.FAILED) private val ZIP_EXT = listOf("zip") private val WCP_EXT = listOf("wcp") } diff --git a/app/src/main/java/com/droiddeck/launcher/QuestXrActivity.kt b/app/src/main/java/com/droiddeck/launcher/QuestXrActivity.kt new file mode 100644 index 0000000000..28270e195c --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/QuestXrActivity.kt @@ -0,0 +1,118 @@ +package com.droiddeck.launcher + +import android.app.NativeActivity +import android.os.Bundle +import android.os.SystemClock +import android.util.Log +import android.widget.Toast +import com.droiddeck.launcher.gpu.SteamVr +import com.droiddeck.launcher.session.SessionService +import com.droiddeck.launcher.session.SessionState +import com.droiddeck.launcher.wayland.CompositorHost +import com.droiddeck.launcher.wayland.WaylandCompositor + +class QuestXrActivity : NativeActivity() { + private var steamVrStarted = false + @Volatile private var closing = false + @Volatile private var steamVrStatus = SteamVr.Status.UNAVAILABLE + private var sessionId: String? = null + override fun onCreate(savedInstanceState: Bundle?) { + sessionId = SessionState.sessionId + SessionService.setXrActivityVisible(this, true) + super.onCreate(savedInstanceState) + } + + fun onXrActive(active: Boolean) { + if (active) { + check(CompositorHost.isStarted) { "DroidDeck compositor is not running" } + SessionService.resume(this) + WaylandCompositor.nativeSetCardboard(false, 1, 0.064f, 3f, 4f, 0f, 0f, 90f, 0f, 0f, false, 0f) + WaylandCompositor.nativeSetFrameGenArmed(false, 0, 0) + WaylandCompositor.nativeSetZeroCopy(false) + CompositorHost.attachXr() + WaylandCompositor.nativeVsync(System.nanoTime()) + check(WaylandCompositor.nativeWaitSurface(3000)) { "XR frame GPU handshake timed out" } + } + SessionService.setXrActivityVisible(this, active) + if (active) startSteamVr() + } + + private fun startSteamVr() { + if (!steamVrStarted) { + steamVrStarted = true + Thread({ + try { + val started = synchronized(steamVrLock) { + if (closing || !sessionAlive()) false else { + steamVrOwner = this + SteamVr.run(this, "start") + } + } + if (!started) { + if (!closing) leaveXr("SteamVR start failed", sessionAlive()) + return@Thread + } + val startupDeadline = SystemClock.elapsedRealtime() + 30_000 + var lastRunning: Long? = null + while (!closing) { + if (!sessionAlive()) { + leaveXr("Steam session ended", false) + break + } + steamVrStatus = SteamVr.status(this) + val now = SystemClock.elapsedRealtime() + if (steamVrStatus == SteamVr.Status.RUNNING) lastRunning = now + val deadline = lastRunning?.plus(5_000) ?: startupDeadline + if (steamVrStatus != SteamVr.Status.RUNNING && now >= deadline) { + leaveXr("SteamVR stopped or did not finish starting", true) + break + } + Thread.sleep(1000) + } + } finally { + synchronized(steamVrLock) { + // A retiring activity must not stop a replacement's SteamVR session. + if (steamVrOwner === this) { + if (sessionAlive()) SteamVr.run(this, "stop") + steamVrOwner = null + } + } + } + }, "quest-steamvr-start").start() + } + } + + private fun sessionAlive() = SessionState.running && !SessionState.stopRequested && + sessionId != null && SessionState.sessionId == sessionId + + private fun leaveXr(reason: String, failed: Boolean) { + Log.w("DroidDeckXR", reason) + closing = true + runOnUiThread { + if (failed) Toast.makeText(this, R.string.cardboard_steamvr_failed, Toast.LENGTH_LONG).show() + finish() + } + } + + fun onXrFrame(frameTimeNanos: Long) { + WaylandCompositor.nativeVsync(frameTimeNanos) + } + + fun onXrStatus(): Int = steamVrStatus.ordinal + + override fun onDestroy() { + closing = true + SessionService.setXrActivityVisible(this, false) + super.onDestroy() + } + + override fun onStop() { + SessionService.setXrActivityVisible(this, false) + super.onStop() + } + + companion object { + private val steamVrLock = Any() + private var steamVrOwner: QuestXrActivity? = null + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index e7c1888632..370784b1f6 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -48,10 +48,18 @@ import com.droiddeck.launcher.stores.Store import com.droiddeck.launcher.stores.StoreAchievements import com.droiddeck.launcher.stores.StoreGameSidecar import com.droiddeck.launcher.stores.StoreLaunchRequests +import com.droiddeck.launcher.stores.epic.EpicClient import com.droiddeck.launcher.ui.SessionAchievements import com.droiddeck.launcher.gpu.Cardboard import com.droiddeck.launcher.gpu.FrameGen import com.droiddeck.launcher.gpu.HeadTracker +import com.droiddeck.launcher.glasses.Glasses +import com.droiddeck.launcher.glasses.GlassesScreen +import com.droiddeck.launcher.glasses.GlassesRendering +import com.droiddeck.launcher.glasses.SpatialTracking +import com.droiddeck.launcher.glasses.TrackingRecovery +import kotlinx.coroutines.cancel +import kotlinx.coroutines.launch import com.droiddeck.launcher.gpu.SteamVr import com.droiddeck.launcher.gpu.ScreenEffectLooks import com.droiddeck.launcher.gpu.ScreenEffects @@ -64,12 +72,15 @@ import com.droiddeck.launcher.input.ControllerPrefs import com.droiddeck.launcher.input.SessionClipboard import com.droiddeck.launcher.input.OnScreenControls import com.droiddeck.launcher.input.PadBridge +import com.droiddeck.launcher.input.PadMouse +import com.droiddeck.launcher.input.PadState import com.droiddeck.launcher.input.SteamControllerBle import com.droiddeck.launcher.input.PointerGestures import com.droiddeck.launcher.input.SecondScreenDisplay import com.droiddeck.launcher.input.SecondScreenDisplays import com.droiddeck.launcher.input.SecondScreenMode import com.droiddeck.launcher.input.TouchpadGestures +import com.droiddeck.launcher.input.ScrollTouchGestures import com.droiddeck.launcher.runtime.LinuxRuntime import com.droiddeck.launcher.session.LoadingState import com.droiddeck.launcher.session.PerfHud @@ -141,6 +152,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private lateinit var loading: LoadingState private lateinit var hud: PerfHud private var padBridge: PadBridge? = null + private var joyConVr: com.droiddeck.launcher.input.JoyConVr? = null + private var handCamera: com.droiddeck.launcher.handtracking.HandCamera? = null private var padMotion: com.droiddeck.launcher.input.PadMotion? = null private var resumed = false private val deckPadListener: () -> Unit = { uiHandler.post { updatePadMotion(); openDeckRing("deck pad changed"); applyUnfoldedControls() } } @@ -176,6 +189,13 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private var watching = true private lateinit var touchpad: TouchpadGestures private lateinit var threeFingerTap: com.droiddeck.launcher.input.ThreeFingerTap + private lateinit var scrollTouch: ScrollTouchGestures + private lateinit var padMouse: PadMouse + @Volatile private var padMouseOn = false + private var padMouseCheckedAt = 0L + private var scrollTouchGesture = false + private var scrollRestX = 0f + private var scrollRestY = 0f private var touchMode by mutableStateOf(SessionPrefs.TOUCH_AUTO) private var cursorPos by mutableStateOf(androidx.compose.ui.geometry.Offset(-100f, -100f)) private var cursorVisible by mutableStateOf(false) @@ -191,6 +211,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { if (pointerLocked == locked) return@post pointerLocked = locked Log.i(TAG, "pointer lock " + if (locked) "taken by a program" else "released") + padMouseCheckedAt = 0L + if (::padMouse.isInitialized) padMouseMode() // Touchpad deltas are measured from the middle while locked (moveLockedPointer). if (locked && ::touchpad.isInitialized) { drawnRect()?.let { touchpad.place(it.centerX(), it.centerY()) } @@ -239,6 +261,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private var leaving by mutableStateOf(false) private var closeAtOnce = false private var drawerComponents by mutableStateOf(null) + private var drawerDefaultProton by mutableStateOf(null) private val drawerComponentMenu by lazy { ComponentsMenu(this, uiHandler) } private var drawerGameProfileId by mutableStateOf(null) private val drawerGameInventory = GameProfileInventoryCache() @@ -277,6 +300,25 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private var steamVrStatus by mutableStateOf(null) private var steamVrSwitchedPicture by mutableStateOf(false) private var steamVrSeenRunning = false + private val steamVrRecovery by lazy { com.droiddeck.launcher.gpu.SteamVrRecovery(this) { + resumed && !ended && SessionState.running && !isInPictureInPictureMode + } } + private var activeCardboard = Cardboard.OFF + private var glasses by mutableStateOf(Glasses.state.value) + private var glassesSettings by mutableStateOf(Glasses.settings.value) + private var glassesScreen: GlassesScreen? = null + private var glassesOutputActive by mutableStateOf(false) + private var trackingRecovery by mutableStateOf(null) + private var glasses3dForVr = false + private var ended = false + private var glassesPresent = false + private var steamVrAutoTried = false + private var steamVrInstallTried = false + @Volatile private var steamVrRequestGeneration = 0L + private var headTracking by mutableStateOf(false) + private var glassesSlot by mutableStateOf(0) + private var glassesKey: List = emptyList() + private val glassesScope = kotlinx.coroutines.MainScope() private val hasRotationSensor by lazy { (getSystemService(SENSOR_SERVICE) as android.hardware.SensorManager).let { it.getDefaultSensor(android.hardware.Sensor.TYPE_GAME_ROTATION_VECTOR) @@ -317,10 +359,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private fun followPanelRefresh(displayId: Int) { if (!CompositorHost.isStarted) return - val display = (if (Build.VERSION.SDK_INT >= 30) display else windowManager.defaultDisplay) ?: return - if (display.displayId != displayId) return - val hz = display.refreshRate - if (hz > 1f) WaylandCompositor.nativeSetOutputRefreshRate(hz) + val output = glassesScreen?.display + ?: (if (Build.VERSION.SDK_INT >= 30) display else windowManager.defaultDisplay) ?: return + if (output.displayId != displayId) return + applyOutputPacing() } private var isHomeApp by mutableStateOf(false) private var androidApps by mutableStateOf>(emptyList()) @@ -328,17 +370,25 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private val deviceListener = object : InputManager.InputDeviceListener { override fun onInputDeviceAdded(deviceId: Int) { logInputDevice("connected", deviceId) + joyConVr?.refresh() padBridge?.syncConnectedControllers() refreshControls() updatePointerCapture() + updateHandCamera() } override fun onInputDeviceRemoved(deviceId: Int) { Log.i(TAG, "input device $deviceId disconnected") + joyConVr?.refresh() padBridge?.onDeviceRemoved(deviceId) + if (::padMouse.isInitialized) padMouse.reset() refreshControls() updatePointerCapture() + updateHandCamera() + } + override fun onInputDeviceChanged(deviceId: Int) { + joyConVr?.refresh() + refreshControls() } - override fun onInputDeviceChanged(deviceId: Int) = refreshControls() } private var runtimeRemovalBlocked = false @@ -362,17 +412,22 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { SessionState.programArgs = intent.getStringArrayExtra(SessionService.EXTRA_PROGRAM_ARGS)?.toList().orEmpty() SessionState.steamUi = intent.getStringExtra(SessionService.EXTRA_STEAM_UI) SessionState.steamUrl = intent.getStringExtra(SessionService.EXTRA_STEAM_URL) + SessionState.steamVr = intent.getBooleanExtra(EXTRA_STEAMVR, false) + } else if (intent.getBooleanExtra(EXTRA_STEAMVR, false) && SessionState.mode == SessionService.MODE_STEAM) { + SessionState.steamVr = true } + if (SessionState.steamVr) Glasses.prepareSteamVrStart() if (intent.action == SessionService.ACTION_AGENT_START) { SessionEvents.record("agent.start_requested", mapOf("mode" to SessionState.mode)) } + com.droiddeck.launcher.gpu.SteamVrHealth.begin(this, SessionState.sessionId) window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) if (!SessionState.running) { SessionState.fpsLimit = SessionPrefs.fpsLimit( this, SessionPrefs.prefMode(intent.getStringExtra(SessionService.EXTRA_MODE) ?: SessionService.MODE_STEAM), ) } - Log.i(TAG, "perf: " + PerfMode.apply(this, SessionState.fpsLimit)) + applyOutputPacing() if (!SessionState.running) SessionState.followScreen = followChoice() applyFollowOrientation(resources.configuration) goFullscreen() @@ -402,6 +457,16 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { bridge.setSelectSteam(ControllerPrefs.read(this).selectSteam) padBridge = bridge SessionState.padBridge = bridge + if (Build.VERSION.SDK_INT >= 31) { + val vr = com.droiddeck.launcher.input.JoyConVr(this, File(filesDir, ".wayland-rt/${com.droiddeck.launcher.input.JoyConVr.FILE}")) { taken, released -> + if (joyConVr == null) return@JoyConVr + taken.forEach(bridge::onDeviceRemoved) + if (released.isNotEmpty()) bridge.syncConnectedControllers() + updateHandCamera() + } + bridge.setExcluded(vr::owns) + joyConVr = vr + } SteamControllerBle.listener = { uiHandler.post { updatePadMotion(); refreshControls() } } steamController = SteamControllerBle(this).also { it.start() } padMotion = com.droiddeck.launcher.input.PadMotion(this) { @@ -419,6 +484,16 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { keyboard = KeyboardHost(this).also { root.addView(it) } touchpad = TouchpadGestures(PointerGestures.slop(this), pointerListener) threeFingerTap = com.droiddeck.launcher.input.ThreeFingerTap(PointerGestures.slop(this) * 2) + padMouse = PadMouse(padMouseListener) + bridge.setTouchRoute(object : PadBridge.TouchRoute { + override fun active(): Boolean = if (Looper.myLooper() == Looper.getMainLooper()) padMouseMode() else padMouseOn + override fun accept(state: PadState) { + if (Looper.myLooper() == Looper.getMainLooper()) padMouse.onTouchPad(state) + else PadState().also { it.copyFrom(state) }.let { copy -> uiHandler.post { padMouse.onTouchPad(copy) } } + } + }) + scrollTouch = ScrollTouchGestures(PointerGestures.slop(this), + android.view.ViewConfiguration.get(this).scaledMinimumFlingVelocity.toFloat(), scrollListener) val noCursor = android.view.PointerIcon.getSystemIcon(this, android.view.PointerIcon.TYPE_NULL) root.pointerIcon = noCursor surfaceView.pointerIcon = noCursor @@ -449,6 +524,37 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { sessionOverlay = createSessionOverlay() root.addView(sessionOverlay) setContentView(root) + glassesScope.launch { Glasses.state.collect { + glasses = it + onGlassesChanged() + updateJoyConTracking() + updateHandCamera() + } } + glassesScope.launch { Glasses.settings.collect { + glassesSettings = it + onGlassesChanged() + updateJoyConTracking() + updateHandCamera() + } } + glassesScope.launch { com.droiddeck.launcher.handtracking.HandTracking.settings.collect { updateHandCamera() } } + glassesScope.launch { + while (true) { + updateTrackingRecovery() + kotlinx.coroutines.delay(100) + } + } + glassesScope.launch { + while (true) { + if (SessionState.running && SessionState.mode == SessionService.MODE_STEAM && + (SessionState.steamVr || steamVrStatus == SteamVr.Status.RUNNING)) { + val lost = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) { + com.droiddeck.launcher.gpu.SteamVrHealth.deviceLost() + } + if (lost) steamVrRecovery.detected() + } + kotlinx.coroutines.delay(2000) + } + } pip = com.droiddeck.launcher.session.SessionPipController(this, ::pipBounds, ::showPipUi) surfaceView.addOnLayoutChangeListener { _, _, _, _, _, _, _, _, _ -> pip.refresh() } pip.refresh() @@ -479,6 +585,13 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { isFocusableInTouchMode = true defaultFocusHighlightEnabled = false setContent { + androidx.compose.runtime.SideEffect { + com.droiddeck.launcher.glasses.GlassesMenuMirror.setSessionMenuVisible(this@SessionActivity, + (drawerOpen || achievementsOpen || pcKeyboardOpen) && !pipUi && steamVrStatus != SteamVr.Status.RUNNING) + } + androidx.compose.runtime.DisposableEffect(Unit) { + onDispose { com.droiddeck.launcher.glasses.GlassesMenuMirror.setSessionMenuVisible(this@SessionActivity, false) } + } androidx.compose.runtime.LaunchedEffect(drawerOpen, pcKeyboardOpen, achievementsOpen, pipUi) { updatePointerCapture() } androidx.compose.runtime.LaunchedEffect(picturePosition, SessionState.running, pipUi, cardboard.enabled) { applyGameAlignment() } DroidDeckTheme { @@ -495,6 +608,26 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { CursorOverlay(cursorPos, cursorVisible, resources.displayMetrics.density, cursorImage, cursorHotX, cursorHotY, cursorImageScale) if (hud.text.isNotEmpty()) HudText(hud.text) + if (glassesOutputActive && !loading.visible) com.droiddeck.launcher.ui.GlassesPlayingHint(glasses.model) + if (trackingRecovery != null && !drawerOpen && !pcKeyboardOpen && !loading.visible) { + androidx.compose.ui.viewinterop.AndroidView( + factory = { com.droiddeck.launcher.ui.TrackingRecoveryView(it) }, + modifier = Modifier.fillMaxSize(), + update = { it.update(trackingRecovery, !glassesOutputActive && glasses.usable && glasses.sbs) }, + ) + } + if (GlassesRendering.usesGlasses(glasses, glassesOutputActive, steamVrStatus == SteamVr.Status.RUNNING) && + headTracking && !drawerOpen && !pcKeyboardOpen && !loading.visible) com.droiddeck.launcher.ui.GlassesRecenterButton( + controllerSettings?.tint ?: android.graphics.Color.rgb(90, 160, 255), controllerSettings?.opacity ?: 100, + onRecenterJoyCons = if (steamVrStatus == SteamVr.Status.RUNNING && + glasses.usesSpatialControllers(glassesSettings) && glassesSettings.joyConTracking) + joyConVr?.let { { it.recenter() } } else null, + ) { headTracker?.recenter() } + if (glasses.present && !drawerOpen && !pcKeyboardOpen && !loading.visible) com.droiddeck.launcher.ui.GlassesCornerButton(glassesSlot, + controllerSettings?.tint ?: android.graphics.Color.rgb(90, 160, 255), controllerSettings?.opacity ?: 100) { + drawerPage = com.droiddeck.launcher.ui.SessionDrawerPage.GLASSES + drawerOpen = true + } if (loading.visible) LoadingOverlay( loading.step, loading.percent, loading.elapsed, loading.hint, loading.ended, topic = loading.topic, readable = loading.readable, @@ -513,7 +646,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { androidx.compose.runtime.LaunchedEffect(drawerOpen) { if (drawerOpen) { syncLossless() - padBridge?.releaseAll() + releasePads() androidx.compose.runtime.withFrameNanos { } val requested = sessionOverlay.requestFocus() Log.i(TAG, "drawer root focus requested=$requested focused=${sessionOverlay.hasFocus()}") @@ -521,12 +654,18 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { releaseDrawerDirection() } } - LaunchedEffect(cardboard.enabled, steamVrSwitchedPicture) { - while (cardboard.enabled || steamVrSwitchedPicture) { + val glassesVr = glasses.usable && glasses.canControl + val steamVrRequested = SessionState.steamVr + val pollSteamVr = SteamVr.shouldPoll(steamVrStatus, cardboard.enabled, + steamVrSwitchedPicture, glassesVr, steamVrRequested) || (drawerOpen && drawerPage == SessionDrawerPage.VR) + LaunchedEffect(pollSteamVr) { + while (pollSteamVr) { + val request = steamVrRequestGeneration + val session = SessionState.sessionId val now = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) { SteamVr.status(this@SessionActivity) } - onSteamVrStatus(now) + if (request == steamVrRequestGeneration && session == SessionState.sessionId) onSteamVrStatus(now) kotlinx.coroutines.delay(3000) } } @@ -539,7 +678,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { achievementsInFront = found if (found == null) achievementsOpen = false } - androidx.compose.runtime.LaunchedEffect(pcKeyboardOpen) { if (pcKeyboardOpen) padBridge?.releaseAll() } + androidx.compose.runtime.LaunchedEffect(pcKeyboardOpen) { if (pcKeyboardOpen) releasePads() } + LaunchedEffect(pcKeyboardOpen, drawerOpen, achievementsOpen) { + if (pcKeyboardOpen || drawerOpen || achievementsOpen) padMouse.reset() + } if (pcKeyboardOpen) com.droiddeck.launcher.ui.PcKeyboard( sendKey = { code, down -> if (CompositorHost.isStarted) sendGuestKey(code, down) }, onAndroidKeyboard = { pcKeyboardOpen = false; keyboard?.toggle() }, @@ -560,7 +702,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { cardboardSensor = hasRotationSensor, onCardboard = { c -> SessionPrefs.setCardboard(this@SessionActivity, c); applyCardboard(c) }, onCardboardRecenter = { headTracker?.recenter() }, + glassesPresent = glasses.present, + glassesOutput = glassesOutputActive, + onGlassesRecenter = { + headTracker?.recenter() + com.droiddeck.launcher.glasses.GlassesMenuMirror.recenter() + }, steamVr = steamVrStatus, + immersiveSteamVr = com.droiddeck.launcher.session.QuestExperimental.isSupported(), onSteamVr = { action -> steamVrAction(action) }, textureAnisotropy = if (drawerGameProfileId == null) textureAnisotropy else drawerTextureAnisotropy, textureLodBias = if (drawerGameProfileId == null) textureLodBias else drawerTextureLodBias, @@ -741,10 +890,13 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { onGameNoSteam = ::setDrawerGameNoSteam, onComponentSwap = { pid, comp, value -> swapDrawerComponent(pid, comp, value) }, onGameComponent = ::setDrawerGameComponent, + defaultProtonId = drawerDefaultProton, + onDefaultProton = ::chooseDrawerDefaultProton, + onGameProton = ::setDrawerGameProton, )) LaunchedEffect(achievementsOpen) { if (achievementsOpen) { - padBridge?.releaseAll() + releasePads() withFrameNanos { } sessionOverlay.requestFocus() } @@ -860,8 +1012,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { Thread({ val applied = runCatching { ComponentsManager.applyQueued(this) }.getOrDefault(emptyList()) val snap = runCatching { ComponentsManager.snapshot(this) }.getOrNull() + val chosen = snap?.let { s -> runCatching { ProtonDefault.selectedId(this, s.protons.map { it.proton }) }.getOrNull() } uiHandler.post { drawerComponents = snap + drawerDefaultProton = chosen if (applied.isNotEmpty()) android.widget.Toast.makeText(this, getString(R.string.main_applied, applied.joinToString(", ")), android.widget.Toast.LENGTH_LONG).show() } }, "drawer-components").start() @@ -1005,6 +1159,46 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { }, "drawer-game-component").start() } + private fun chooseDrawerDefaultProton(protonId: String) { + val proton = drawerComponents?.protons?.firstOrNull { it.proton.id == protonId }?.proton ?: return + drawerDefaultProton = protonId + Thread({ + val message = runCatching { + when (ProtonDefault.request(this, proton)) { + ProtonDefault.Outcome.LIVE -> getString(R.string.comp_default_live, proton.name) + ProtonDefault.Outcome.NEXT_START -> getString(R.string.comp_default_next, proton.name) + ProtonDefault.Outcome.NOT_RUNNABLE -> getString(R.string.comp_default_not_runnable, proton.name) + } + }.getOrElse { e -> getString(R.string.comp_default_failed, e.message ?: e.javaClass.simpleName) } + uiHandler.post { + Toast.makeText(this, message, Toast.LENGTH_LONG).show() + refreshDrawerComponents() + refreshDrawerGameProfile() + } + }, "drawer-default-proton").start() + } + + private fun setDrawerGameProton(appId: Long, protonId: String?) { + val name = drawerGameProfileRefresh.data?.profiles?.firstOrNull { it.first == appId }?.second ?: appId.toString() + val proton = protonId?.let { id -> drawerComponents?.protons?.firstOrNull { it.proton.id == id }?.proton ?: return } + Thread({ + val message = runCatching { + getString( + when (ProtonDefault.requestGame(this, appId.toString(), proton)) { + ProtonDefault.Outcome.LIVE -> R.string.comp_game_proton_live + ProtonDefault.Outcome.NEXT_START -> R.string.comp_game_proton_next + ProtonDefault.Outcome.NOT_RUNNABLE -> R.string.comp_game_proton_not_runnable + }, + name, + ) + }.getOrElse { e -> getString(R.string.session_profile_save_failed, e.message ?: e.javaClass.simpleName) } + uiHandler.post { + Toast.makeText(this, message, Toast.LENGTH_LONG).show() + refreshDrawerGameProfile() + } + }, "drawer-game-proton").start() + } + private fun setDrawerGameFexPreset(appId: Long, preset: String?) { if (drawerGameFexPresetSaving) return drawerGameFexPresetSaving = true @@ -1063,7 +1257,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { com.droiddeck.launcher.frontend.Library.nameForProgram(program)?.let { getString(R.string.session_starting_named, it) } ?: getString(R.string.session_starting_program) } - else -> getString(R.string.load_starting_steam) + else -> if (com.droiddeck.launcher.session.SessionPrefs.activeSteamClientArch(this) == "x86_64") getString(R.string.load_starting_steam_x64) + else getString(R.string.load_starting_steam) } private fun shareCurrentSessionLogs() { @@ -1103,6 +1298,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { val nextTouchMode = SessionPrefs.touchMode(this) if (touchMode != nextTouchMode) { if (::touchpad.isInitialized) touchpad.cancel() + if (::scrollTouch.isInitialized) scrollTouch.cancel() if (CompositorHost.isStarted) { WaylandCompositor.nativeSendTouch(3, -1, 0, 0) listOf(PointerGestures.BTN_LEFT, PointerGestures.BTN_RIGHT, PointerGestures.BTN_MIDDLE).forEach { @@ -1179,7 +1375,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } loading.percent = -1 loading.say(getString(R.string.session_starting_session), LoadingState.Topic.SESSION, readable = false) - if (surfaceView.holder.surface?.isValid == true) surfaceCreated(surfaceView.holder) + outputHolder().let { if (it.surface?.isValid == true) surfaceCreated(it) } } }, "runtime-install").start() } @@ -1243,7 +1439,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } override fun surfaceCreated(holder: SurfaceHolder) { - if (installingRuntime || SessionState.stopRequested) return + if (holder !== outputHolder()) return + if (installingRuntime || SessionState.stopRequested || ended) return if (!SessionState.running) { SessionEvents.transition(SessionPhase.STARTING_COMPOSITOR, "compositor.starting") } @@ -1252,13 +1449,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { val turnip = TurnipDriver(this) com.droiddeck.launcher.gpu.DriverSetupLog.write(this, "surface.driver-setup") + if (!CompositorHost.isStarted) CompositorHost.displayChoice = SessionPrefs.androidDriver(this) val driverId = if (CompositorHost.isStarted) null else turnip.install() val previous = SessionState.outputSize val live = if (SessionState.followScreen && !isInPictureInPictureMode) com.droiddeck.launcher.session.SessionDisplay.followSize(holder.surfaceFrame.width(), holder.surfaceFrame.height()) else null - val size = live ?: if (SessionState.running) previous else outputSize() + val size = live ?: if (SessionState.running) previous else glassesOutputSize() ?: outputSize() SessionState.outputSize = size if (!SessionState.running) SessionState.refreshHz = refreshHz() val panel = panelBounds() @@ -1271,8 +1469,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { WaylandCompositor.nativeSetUpscaler(SessionPrefs.upscaler(this)) WaylandCompositor.nativeSetUpscaleSharpness(SessionPrefs.upscaleSharpness(this)) SessionPrefs.screenEffects(this).push(SessionPrefs.upscaler(this)) - panelSizeMm().let { (w, h) -> SessionPrefs.cardboard(this).push(w, h) } + activeCardboard = effectiveCardboard(SessionPrefs.cardboard(this)) + pushCardboard(activeCardboard) WaylandCompositor.nativeSetCardboardPoseFile(File(filesDir, ".wayland-rt/droiddeck-headpose").path) + com.droiddeck.launcher.glasses.SpatialTracking.attachPublisher(File(filesDir, ".wayland-rt/droiddeck-spatialpose").path) if (!SessionState.running) { val waylandLog = File(SessionPaths.beginOrCurrent(this), "wayland.log") WaylandCompositor.setSessionLogFile(waylandLog) @@ -1284,7 +1484,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } if (!CompositorHost.isStarted) { val mode = SessionPrefs.prefMode(intent.getStringExtra(SessionService.EXTRA_MODE) ?: SessionService.MODE_STEAM) - val probe = HdrSupport.probe(this) + val probe = HdrSupport.probe(this, glassesScreen?.display) WaylandCompositor.nativeSetHdrDisplay( probe.displayId, probe.name, probe.formats, probe.hdr10, probe.maxLuminance, probe.maxAverageLuminance, probe.minLuminance, @@ -1308,8 +1508,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { CompositorHost.startOrAttach( holder.surface, runtimeDir.path, driverId?.let { turnip.driverPath(it) }, driverId?.let { turnip.libraryName(it) }, - applicationInfo.nativeLibraryDir, size.first, size.second, refreshHz(), SessionState.fpsLimit, + applicationInfo.nativeLibraryDir, size.first, size.second, refreshHz(), outputFpsLimit(), ) + onOutputAttached(holder) if (SessionState.running && size != previous) { Log.i(TAG, "follow screen: ${previous.first}x${previous.second} -> ${size.first}x${size.second} on a new surface") WaylandCompositor.nativeResizeOutput(size.first, size.second) @@ -1333,6 +1534,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private var surfaceH = 0 override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) { + if (holder !== outputHolder()) return val resized = surfaceW != 0 && (width != surfaceW || height != surfaceH) surfaceW = width surfaceH = height @@ -1376,8 +1578,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } override fun surfaceDestroyed(holder: SurfaceHolder) { + // Hiding the phone surface after a handoff delivers a late destruction + // callback. It must not reset the new output's size or attachment. + if (holder !== outputHolder()) return surfaceW = 0 surfaceH = 0 + glassesOutputActive = false CompositorHost.detach(holder.surface) } @@ -1402,14 +1608,32 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } private fun refreshHz(): Float { + glassesScreen?.hz?.takeIf { it > 1f }?.let { return it } val display = if (Build.VERSION.SDK_INT >= 30) display else windowManager.defaultDisplay val wanted = window.attributes.preferredDisplayModeId val hz = display?.supportedModes?.firstOrNull { wanted != 0 && it.modeId == wanted }?.refreshRate ?: display?.refreshRate ?: 60f - val capped = minOf(hz, PerfMode.peakRefreshCap(this)) + val mirrorCap = mirrorRefreshLimit().takeIf { it > 0 }?.toFloat() ?: Float.POSITIVE_INFINITY + val capped = minOf(hz, PerfMode.peakRefreshCap(this), mirrorCap) return if (capped > 1f) capped else 60f } + private fun mirrorRefreshLimit(): Int = + GlassesRendering.mirrorRefreshLimit(glassesSettings, glasses, glassesScreen != null) + + private fun outputFpsLimit(): Int = GlassesRendering.fpsLimit(SessionState.fpsLimit, mirrorRefreshLimit()) + + private fun applyOutputPacing() { + Log.i(TAG, "perf: " + PerfMode.apply(this, outputFpsLimit(), mirrorRefreshLimit())) + if (CompositorHost.isStarted) { + val hz = refreshHz() + val changed = kotlin.math.abs(SessionState.refreshHz - hz) > 0.1f + CompositorHost.updatePacing(hz, outputFpsLimit()) + pushCardboard(activeCardboard) + if (changed && ::surfaceView.isInitialized) applyFrameGen() + } + } + private fun applyFrameGen() { val hz = refreshHz() Thread({ @@ -1468,11 +1692,15 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } private fun onSessionEnded(status: Int) { + ended = true + ++steamVrRequestGeneration if (isInPictureInPictureMode) { runOnUiThread { finish() } return } closeSecondScreen(reset = true) + updateGlassesScreen() + updateHeadTracker() if (status == 0) { runOnUiThread { if (isFinishing || isDestroyed) return@runOnUiThread @@ -1514,9 +1742,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { focusEndedScreen() } + private fun releasePads() { + padBridge?.releaseAll() + joyConVr?.releaseButtons() + } + private fun focusEndedScreen() { drawerOpen = false - padBridge?.releaseAll() + releasePads() uiHandler.post { sessionOverlay.requestFocus() } } @@ -1587,6 +1820,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { return super.dispatchKeyEvent(event) } if (pipUi) return true + val pad = com.droiddeck.launcher.input.JoyCon.normalize(event) + if (pad !== event) return dispatchKeyEvent(pad) val fromController = PadBridge.isControllerKeyEvent(event) if (fromController && event.action == KeyEvent.ACTION_DOWN) { if (drawerOpen && !drawerControllerActive) sessionOverlay.requestFocus() @@ -1609,7 +1844,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { if (drawerOpen) { if (fromController && (event.keyCode == KeyEvent.KEYCODE_BUTTON_L1 || event.keyCode == KeyEvent.KEYCODE_BUTTON_R1)) { if (event.action == KeyEvent.ACTION_DOWN && event.repeatCount == 0) { - drawerPage = sessionDrawerPages(SessionState.mode == SessionService.MODE_STEAM && secondScreenDisplays.isNotEmpty()) + drawerPage = sessionDrawerPages(SessionState.mode == SessionService.MODE_STEAM && secondScreenDisplays.isNotEmpty(), glasses.present) .step(drawerPage, if (event.keyCode == KeyEvent.KEYCODE_BUTTON_R1) 1 else -1) releaseDrawerDirection() } @@ -1638,6 +1873,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { return true } if ((pcKeyboardOpen || achievementsOpen) && fromController) return super.dispatchKeyEvent(event) + if (joyConVr?.onKeyEvent(event) == true) return true + if (fromController && event.keyCode != KeyEvent.KEYCODE_BACK && padMouseMode() && padMouse.onKey(event)) return true if (event.keyCode != KeyEvent.KEYCODE_BACK && padBridge?.onKeyEvent(event) == true) return true if (CompositorHost.isStarted && event.keyCode != KeyEvent.KEYCODE_BACK && !fromController) { val down = event.action == KeyEvent.ACTION_DOWN @@ -1681,6 +1918,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } if (drawerDirectionKey != KeyEvent.KEYCODE_UNKNOWN) releaseDrawerDirection() if ((pcKeyboardOpen || achievementsOpen) && PadBridge.isControllerMotionEvent(event)) return super.dispatchGenericMotionEvent(event) + if (joyConVr?.onMotionEvent(event) == true) return true + if (PadBridge.isControllerMotionEvent(event) && padMouseMode() && padMouse.onMotion(event)) return true if (padBridge?.onMotionEvent(event) == true) return true if (event.isFromSource(android.view.InputDevice.SOURCE_MOUSE) && !drawerOpen && onMouse(event)) return true return super.dispatchGenericMotionEvent(event) @@ -1783,6 +2022,67 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } } + private val scrollListener = object : ScrollTouchGestures.Listener { + override fun onMove(x: Float, y: Float) { + val rect = drawnRect() ?: return + val cx = x.coerceIn(rect.left, rect.right) + val cy = y.coerceIn(rect.top, rect.bottom) + WaylandCompositor.nativeSendPointer(1, InputSpace.x(cx, surfaceView.width), InputSpace.y(cy, surfaceView.height)) + cursorVisible = false + } + override fun onButton(button: Int, pressed: Boolean) { + WaylandCompositor.nativeSendSceneInput(3, button, if (pressed) 1 else 0) + } + override fun onScroll(dx: Float, dy: Float) { + val rect = drawnRect() ?: return + val out = SessionState.outputSize + scrollRestX += dx * out.first / rect.width() + scrollRestY += dy * out.second / rect.height() + val h = scrollRestX.toInt() + val v = scrollRestY.toInt() + if (h == 0 && v == 0) return + scrollRestX -= h + scrollRestY -= v + WaylandCompositor.nativeSendSceneInput(11, ScrollTouchGestures.wheelUnits(v, out.second), ScrollTouchGestures.wheelUnits(h, out.first)) + } + override fun onLongPress() = pointerListener.onLongPress() + } + + private val padMouseListener = object : PadMouse.Listener { + override fun active(): Boolean = padMouseMode() + override fun onScrollStart() { + scrollRestX = 0f + scrollRestY = 0f + val rect = drawnRect() ?: return + val x = rect.left + rect.width() * PAD_SCROLL_POINTER_X + WaylandCompositor.nativeSendPointer(1, InputSpace.x(x, surfaceView.width), InputSpace.y(rect.centerY(), surfaceView.height)) + cursorVisible = false + } + override fun onScroll(dx: Float, dy: Float) = scrollListener.onScroll(dx, dy) + override fun onKey(evdev: Int, pressed: Boolean) = sendGuestKey(evdev, pressed) + override fun onKeyboard() { + uiHandler.post { togglePcKeyboard() } + } + override fun onNavigate() { + cursorVisible = false + } + override fun scrollSpeed(): Float = (drawnRect()?.height() ?: 0f) * PAD_SCROLL_HEIGHTS_PER_S + } + + private fun padMouseMode(): Boolean { + val now = android.os.SystemClock.uptimeMillis() + if (now - padMouseCheckedAt < PAD_MOUSE_CHECK_MS) return padMouseOn + padMouseCheckedAt = now + val on = !pointerLocked && EpicClient.launcherFocused(this) && !EpicClient.playing(this) + if (padMouseOn && !on) padMouse.reset() + if (!padMouseOn && on) padBridge?.releaseAll() + padMouseOn = on + return on + } + + private fun scrollTouchMode(): Boolean = + (routedTouchMode == SessionPrefs.TOUCH_AUTO || routedTouchMode == SessionPrefs.TOUCH_DIRECT) && padMouseMode() + private fun moveLockedPointer(x: Float, y: Float) { val rect = drawnRect() ?: return val scale = SessionState.outputSize.first / rect.width() @@ -1845,6 +2145,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { if (!::displayManager.isInitialized) return val primaryId = display?.displayId ?: windowManager.defaultDisplay.displayId val candidates = SecondScreenDisplays.available(displayManager, primaryId) + .filter { glassesScreen == null || it.id != glasses.displayId } val oldIds = secondScreenDisplays.map { it.id }.toSet() secondScreenDisplays = candidates val newIds = candidates.map { it.id }.toSet() @@ -2009,6 +2310,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } if (next == routedTouchMode) return if (::touchpad.isInitialized) touchpad.cancel() + if (::scrollTouch.isInitialized) scrollTouch.cancel() if (CompositorHost.isStarted) WaylandCompositor.nativeSendTouch(3, -1, 0, 0) if (next == SessionPrefs.TOUCH_OFF) cursorVisible = false routedTouchMode = next @@ -2042,6 +2344,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { override fun onTouchEvent(event: MotionEvent): Boolean { if (event.isFromSource(android.view.InputDevice.SOURCE_MOUSE)) return onMouse(event) + if (event.actionMasked == MotionEvent.ACTION_DOWN) { + scrollTouchGesture = scrollTouchMode() + scrollRestX = 0f + scrollRestY = 0f + } + if (scrollTouchGesture) return scrollTouch.onTouch(event) if (routedTouchMode == SessionPrefs.TOUCH_OFF) return true if (SessionState.mode == SessionService.MODE_STEAM && SessionState.steamUi != "desktop") { val wasActive = threeFingerTap.active @@ -2196,6 +2504,17 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } private fun updateOnScreenControls() { + updateOnScreenPad() + val c = onScreenControls + glassesSlot = when { + c == null || c.visibility != View.VISIBLE -> 0 + c.isButtonsOnly -> -1 + controllerSettings?.keyboardButton != false -> 2 + else -> 1 + } + } + + private fun updateOnScreenPad() { val forced = File(Environment.getExternalStorageDirectory(), "Download/droiddeck-osc") .takeIf { it.isFile } ?.let { FileUtils.readString(it)?.trim()?.lowercase() } @@ -2278,8 +2597,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { pendingBackAction = null releaseDrawerDirection() onScreenControls?.releaseAll() - padBridge?.releaseAll() + releasePads() touchpad.cancel() + scrollTouch.cancel() guestKeysDown.toList().forEach { sendGuestKey(it, false) } keyboard?.hide() sessionClipboard.stop() @@ -2314,6 +2634,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { if (::pip.isInitialized) pip.changed(inPip) if (!inPip && surfaceW > 0) followWindow(surfaceW, surfaceH) applyUnfoldedControls() + updateGlassesScreen() } override fun startActivityForResult(intent: Intent, requestCode: Int, options: Bundle?) { @@ -2331,15 +2652,22 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { displayManager.registerDisplayListener(displayListener, Handler(Looper.getMainLooper())) refreshSecondScreenDisplays() if (secondScreenMode != SecondScreenMode.NONE && secondScreenPresentation == null) showSecondScreen(secondScreenMode) + startedScreens++ SessionService.setActivityVisible(this, true) + Glasses.rescan() + updateGlassesScreen() + updateHandCamera() } override fun onStop() { if (runtimeRemovalBlocked) { super.onStop(); return } started = false + updateHandCamera() displayManager.unregisterDisplayListener(displayListener) closeSecondScreen(reset = false) - SessionService.setActivityVisible(this, false) + startedScreens = (startedScreens - 1).coerceAtLeast(0) + updateGlassesScreen() + if (startedScreens == 0) SessionService.setActivityVisible(this, false) super.onStop() } @@ -2356,6 +2684,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } if (this.intent.getBooleanExtra(EXTRA_RETURN_HOME, false)) intent.putExtra(EXTRA_RETURN_HOME, true) setIntent(intent) + if (intent.getBooleanExtra(EXTRA_STEAMVR, false) && SessionState.mode == SessionService.MODE_STEAM) { + SessionState.steamVr = true + steamVrAutoTried = false + } if (intent.action == SessionService.ACTION_HOME_GUIDE) { handleHomeGuideIntent(intent) } else if (intent.action == SessionService.ACTION_RESUME) { @@ -2377,6 +2709,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { (getSystemService(INPUT_SERVICE) as? InputManager) ?.registerInputDeviceListener(deviceListener, Handler(Looper.getMainLooper())) if (SessionState.guestPid > 1) padBridge?.syncConnectedControllers() + joyConVr?.refresh() onScreenControls?.reload() controllerSettings = ControllerPrefs.read(this) resumed = true @@ -2399,6 +2732,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { (getSystemService(INPUT_SERVICE) as? InputManager)?.unregisterInputDeviceListener(deviceListener) releaseDrawerDirection() onScreenControls?.releaseAll() + if (::scrollTouch.isInitialized) scrollTouch.cancel() + if (::padMouse.isInitialized) padMouse.reset() resumed = false updatePointerCapture() updatePadMotion() @@ -2409,21 +2744,68 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } private fun steamVrAction(action: String) { + if (action == "start" && com.droiddeck.launcher.session.QuestExperimental.isSupported()) { + startActivity(android.content.Intent(this, QuestXrActivity::class.java)) + return + } + val request = ++steamVrRequestGeneration + val session = SessionState.sessionId + fun currentRequest() = request == steamVrRequestGeneration && session == SessionState.sessionId && !isDestroyed && !ended + if (action == "start") { + SessionState.steamVr = true + steamVrAutoTried = true + } + if (action == "stop") { + SessionState.steamVr = false + Glasses.cancelSteamVrStart() + } + if (glasses.present) { + // Optional stereo starts only after RUNNING is observed. READY can + // arrive repeatedly while the launch worker is still starting VR. + if (action == "install") steamVrStatus = SteamVr.Status.INSTALLING + runSteamVrAction(action, ::currentRequest) { + val ok = SteamVr.run(this, action) + val now = SteamVr.status(this) + uiHandler.post { + if (!currentRequest()) return@post + if (!ok && now != SteamVr.Status.RUNNING) Glasses.cancelSteamVrStart() + onSteamVrStatus(now) + if (!ok) Toast.makeText(this, getString(R.string.cardboard_steamvr_failed), Toast.LENGTH_LONG).show() + } + } + return + } if (action == "start") { switchPictureForSteamVr() steamVrSeenRunning = false } if (action == "stop") restoreSteamVrPicture() if (action == "install") steamVrStatus = SteamVr.Status.INSTALLING - Thread({ + runSteamVrAction(action, ::currentRequest) { val ok = SteamVr.run(this, action) val now = SteamVr.status(this) uiHandler.post { + if (!currentRequest()) return@post + if (!ok && now != SteamVr.Status.RUNNING) Glasses.cancelSteamVrStart() if (!ok && action == "start" && now != SteamVr.Status.RUNNING) restoreSteamVrPicture() onSteamVrStatus(now) if (!ok) Toast.makeText(this, getString(R.string.cardboard_steamvr_failed), Toast.LENGTH_LONG).show() } - }, "steamvr-$action").start() + } + } + + private fun runSteamVrAction(action: String, currentRequest: () -> Boolean, run: () -> Unit) { + if (action != "start") { + steamVrWorker.execute(run) + return + } + Glasses.prepareSteamVrStart { + uiHandler.post { + if (SessionState.steamVr && currentRequest()) steamVrWorker.execute { + if (SessionState.steamVr && currentRequest()) run() + } + } + } } private fun switchPictureForSteamVr() { @@ -2436,8 +2818,54 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { steamVrSwitchedPicture = SessionPrefs.cardboardSourceBeforeSteamVr(this) >= 0 } + private fun usesSpatialControllers() = + GlassesRendering.usesGlasses(glasses, glassesScreen != null, steamVrStatus == SteamVr.Status.RUNNING) && + glasses.usesSpatialControllers(glassesSettings) + + private fun updateJoyConTracking() { + joyConVr?.setActive(steamVrStatus == SteamVr.Status.RUNNING && + (ControllerPrefs.joyConVr(this) || + (usesSpatialControllers() && glassesSettings.joyConTracking))) + } + + private fun updateHandCamera() { + val joyCons = joyConVr?.holding == true + val bare = !joyCons && !controllerConnected() + val want = started && steamVrStatus == SteamVr.Status.RUNNING && (joyCons || bare) && + !usesSpatialControllers() && + com.droiddeck.launcher.handtracking.HandTracking.wanted(this) + handCamera?.bareHands = bare + if (want == (handCamera != null)) return + if (want) { + handCamera = com.droiddeck.launcher.handtracking.HandCamera(this, + File(filesDir, ".wayland-rt/${com.droiddeck.launcher.handtracking.HandCameraShm.FILE}"), preview = false) + .also { + it.bareHands = bare + it.start(com.droiddeck.launcher.handtracking.HandTracking.settings.value.side) + } + } else { + handCamera?.stop() + handCamera = null + } + } + + private fun controllerConnected(): Boolean = InputDevice.getDeviceIds().any { id -> + joyConVr?.owns(id) != true && com.droiddeck.launcher.input.PadBridge.isFromController(InputDevice.getDevice(id)) + } + private fun onSteamVrStatus(now: SteamVr.Status) { + if (ended || isDestroyed) return + val was = steamVrStatus steamVrStatus = now + updateJoyConTracking() + updateHandCamera() + autoStartSteamVr(now) + if ((was == SteamVr.Status.RUNNING) != (now == SteamVr.Status.RUNNING)) applyCardboard(cardboard) + if (now != SteamVr.Status.UNAVAILABLE) Glasses.setVrActive(now == SteamVr.Status.RUNNING) + if (glasses.present) onGlassesSteamVr(now) + if (GlassesRendering.usesGlasses(glasses, glassesScreen != null, now == SteamVr.Status.RUNNING)) { + return + } if (now == SteamVr.Status.RUNNING && cardboard.enabled && !steamVrSwitchedPicture && cardboard.source != Cardboard.SOURCE_SBS) { switchPictureForSteamVr() @@ -2460,23 +2888,186 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } private fun applyCardboard(c: Cardboard) { - val was = cardboard + val was = activeCardboard cardboard = c - if (CompositorHost.isStarted) panelSizeMm().let { (w, h) -> c.push(w, h) } - if (c.enabled && !was.enabled) headTracker?.recenter() + val e = effectiveCardboard(c) + activeCardboard = e + if (CompositorHost.isStarted) pushCardboard(e) + if (e.enabled && !was.enabled) headTracker?.recenter() updateHeadTracker() } + private fun pushCardboard(c: Cardboard) { + val fov = when { + c.viewer != Cardboard.Viewer.VITURE.id -> 0f + c.source == Cardboard.SOURCE_SBS -> glassesSettings.vrFovDeg.toFloat() + else -> glasses.verticalFovDeg + } + panelSizeMm().let { (w, h) -> c.push(w, h, fov, refreshHz()) } + } + + private fun effectiveCardboard(c: Cardboard): Cardboard = GlassesRendering.cardboard( + base = c, + settings = glassesSettings, + state = glasses, + outputActive = glassesScreen != null, + steamVrRunning = steamVrStatus == SteamVr.Status.RUNNING, + ) + private fun updateHeadTracker() { - val want = resumed && cardboard.enabled && cardboard.headTracking + val onGlasses = GlassesRendering.usesGlasses(glasses, glassesScreen != null, + steamVrStatus == SteamVr.Status.RUNNING) + SpatialTracking.setOutputUsesGlasses(onGlasses && !ended) + val c = activeCardboard + val centerView = onGlasses && c.source == Cardboard.SOURCE_SCREEN + val want = !ended && (resumed || (glassesScreen != null && started)) && c.enabled && c.headTracking + val current = headTracker + if (current != null && (!want || current.usesGlasses != onGlasses || current.centerView != centerView)) { + current.stop() + headTracker = null + } if (want) { - val t = headTracker ?: HeadTracker(this) { + val t = headTracker ?: HeadTracker(this, glasses = onGlasses, centerView = centerView) { @Suppress("DEPRECATION") (if (Build.VERSION.SDK_INT >= 30) display else windowManager.defaultDisplay)?.rotation ?: android.view.Surface.ROTATION_0 }.also { headTracker = it } t.start() - } else { - headTracker?.stop() + } + headTracking = headTracker != null + } + + private fun updateTrackingRecovery() { + val onGlasses = GlassesRendering.usesGlasses(glasses, glassesScreen != null, + steamVrStatus == SteamVr.Status.RUNNING) + val spatialView = onGlasses && SpatialTracking.selected && glassesSettings.positionalTracking && + (SessionState.steamVr || steamVrStatus == SteamVr.Status.RUNNING || + (glassesOutputActive && glassesSettings.headTracking && glassesSettings.picture3d == com.droiddeck.launcher.glasses.GlassesSettings.PICTURE_SCREEN)) + val active = started && !ended && SessionState.running && !loading.visible && !pipUi && spatialView + if (active) SpatialTracking.refreshStatus() + trackingRecovery = TrackingRecovery.forSession(active, glasses.canControl, SpatialTracking.status.value) + glassesScreen?.trackingRecovery?.update(trackingRecovery, glasses.sbs) + } + + private fun outputHolder(): SurfaceHolder = glassesScreen?.holder ?: surfaceView.holder + + private fun onOutputAttached(holder: SurfaceHolder) { + if (holder !== outputHolder()) return + glassesOutputActive = glassesScreen?.holder === holder + // Keep the phone's layout for touch/controller coordinates, but remove + // its SurfaceView so it cannot retain the last game frame under the hint. + surfaceView.visibility = if (glassesOutputActive) View.INVISIBLE else View.VISIBLE + Log.i(TAG, "compositor output attached: " + + if (glassesOutputActive) "glasses display ${glassesScreen?.display?.displayId}" else "phone") + } + + private fun restorePhoneOutput(screen: GlassesScreen) { + if (glassesScreen !== screen) return + glassesScreen = null + glassesOutputActive = false + surfaceW = 0 + surfaceH = 0 + CompositorHost.detach(screen.holder.surface) + surfaceView.visibility = View.VISIBLE + applyOutputPacing() + if (surfaceView.holder.surface?.isValid == true) surfaceCreated(surfaceView.holder) + } + + private fun glassesOutputSize(): Pair? { + if (glassesScreen == null || glasses.width <= 0 || glasses.height <= 0) return null + val panel = (if (glasses.sbs) glasses.width / 2 else glasses.width) to glasses.height + val mode = SessionPrefs.prefMode(intent.getStringExtra(SessionService.EXTRA_MODE) ?: SessionService.MODE_STEAM) + val display = com.droiddeck.launcher.session.SessionDisplay + val choice = SessionPrefs.resolutionChoice(this, mode, panel) + val size = display.resolveChoice(panel, choice) + val fixed = choice != display.MATCH_SCREEN && choice != display.FOLLOW_SCREEN && display.presetHeight(choice) == null + return if (fixed) display.resolve(panel, minOf(size.first, size.second), SessionPrefs.SHAPE_AUTO) else size + } + + private fun onGlassesChanged() { + val g = glasses + val s = glassesSettings + val key = listOf(g.present, g.usable, g.displayId, g.sbs, g.sbs90, g.supports30Hz, g.switching3d, g.canControl, g.width, g.height, g.hz, g.resolutions, g.vrActive, s) + if (key == glassesKey) return + glassesKey = key + updateGlassesScreen() + applyCardboard(cardboard) + if (!g.switching3d) { + if (glassesPresent && !g.present) onGlassesUnplugged() + glassesPresent = g.present + } + } + + private fun onGlassesUnplugged() { + val hadVr = steamVrAutoTried + steamVrAutoTried = false + glasses3dForVr = false + if (hadVr && !cardboard.enabled) steamVrAction("stop") + } + + private fun autoStartSteamVr(now: SteamVr.Status) { + if (now == SteamVr.Status.RUNNING) steamVrAutoTried = true + val action = SteamVr.autoAction(now, SessionState.steamVr, loading.visible, + SessionState.mode == SessionService.MODE_STEAM, steamVrAutoTried, steamVrInstallTried) ?: return + if (action == "start") steamVrAutoTried = true else steamVrInstallTried = true + Log.i(TAG, "requested SteamVR $action (glasses=${glasses.model}, output=$glassesOutputActive, control=${glasses.canControl})") + steamVrAction(action) + } + + private fun updateGlassesScreen() { + if (!::surfaceView.isInitialized) return + val g = glasses + val want = started && !ended && !isInPictureInPictureMode && !runtimeRemovalBlocked && g.usable && glassesSettings.gameOnGlasses + val target = if (want) Glasses.glassesDisplay()?.takeIf { it.isValid } else null + val current = glassesScreen + if (current != null && current.display.displayId == target?.displayId) { + current.prefer(Glasses.outputHz(), Glasses.outputResolution()) + applyOutputPacing() + return + } + if (current != null) { + restorePhoneOutput(current) + runCatching { current.dismiss() } + } + if (target != null) { + val screen = GlassesScreen(this, target, Glasses.outputHz(), this, Glasses.outputResolution()) + // show() can create the surface synchronously. Select its holder + // first, otherwise surfaceCreated() rejects the glasses callback. + glassesScreen = screen + applyOutputPacing() + surfaceW = 0 + surfaceH = 0 + screen.setOnDismissListener { + if (glassesScreen === screen) { + restorePhoneOutput(screen) + refreshSecondScreenDisplays() + applyCardboard(cardboard) + } + } + try { + screen.show() + } catch (e: Exception) { + restorePhoneOutput(screen) + runCatching { screen.dismiss() } + Log.w(TAG, "could not show the game on ${target.name}", e) + return + } + Log.i(TAG, "requested game output on ${g.model} (display ${target.displayId})") + } + applyOutputPacing() + refreshSecondScreenDisplays() + applyCardboard(cardboard) + } + + private fun onGlassesSteamVr(now: SteamVr.Status) { + val g = glasses + if (now == SteamVr.Status.RUNNING) { + if (glassesSettings.auto3d && g.can3d && !g.sbs && !glasses3dForVr) { + glasses3dForVr = true + Glasses.set3dForVr(true) + } + } else if (glasses3dForVr && now != SteamVr.Status.UNAVAILABLE) { + glasses3dForVr = false + Glasses.set3dForVr(false) } } @@ -2508,6 +3099,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { override fun onWindowFocusChanged(hasFocus: Boolean) { super.onWindowFocusChanged(hasFocus) + if (!hasFocus && ::padMouse.isInitialized) padMouse.reset() if (runtimeRemovalBlocked) return if (hasFocus && !pipUi) { goFullscreen() @@ -2548,6 +3140,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } override fun onDestroy() { + steamVrRecovery.close() uiHandler.removeCallbacks(steamTouchRetry) if (runtimeRemovalBlocked) { super.onDestroy(); return } watching = false @@ -2556,7 +3149,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { pendingBackAction = null if (::pip.isInitialized) pip.destroyed() closeSecondScreen(reset = false) + glassesScope.cancel() + glassesScreen?.let { screen -> glassesScreen = null; runCatching { screen.dismiss() } } + headTracker?.stop() if (::hud.isInitialized) hud.stop() + joyConVr?.close() + joyConVr = null + handCamera?.stop() + handCamera = null padBridge?.stop() steamController?.stop() if (SessionState.padBridge === padBridge) SessionState.padBridge = null @@ -2610,11 +3210,16 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { companion object { const val EXTRA_RETURN_HOME = "returnHome" + const val EXTRA_STEAMVR = "steamVr" private const val LEAVE_TIMEOUT_MS = 1_500L private const val TAG = "SessionActivity" + private var startedScreens = 0 private const val FEX_MISSING = "droiddeck-fex: x86 Linux programs need" private const val UNBUFFERED_SOURCES = InputDevice.SOURCE_CLASS_JOYSTICK or InputDevice.SOURCE_CLASS_TRACKBALL or InputDevice.SOURCE_CLASS_POSITION private const val CURSOR_PAD_HOLD_MS = 1200L + private const val PAD_MOUSE_CHECK_MS = 500L + private const val PAD_SCROLL_POINTER_X = 0.985f + private const val PAD_SCROLL_HEIGHTS_PER_S = 3f private const val DRAWER_HAT_THRESHOLD = 0.5f private const val DRAWER_STICK_ENTER_THRESHOLD = 0.55f private const val DRAWER_STICK_EXIT_THRESHOLD = 0.35f @@ -2623,6 +3228,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private const val DRAWER_SLOW_REPEAT_FLOOR_MS = 240L private const val DRAWER_FAST_REPEAT_INTERVAL_MS = 90L private const val DRAWER_REPEAT_ACCELERATION_MS = 1_400L + private val steamVrWorker = java.util.concurrent.ThreadPoolExecutor(0, 1, 30, java.util.concurrent.TimeUnit.SECONDS, + java.util.concurrent.LinkedBlockingQueue()) { Thread(it, "steamvr") } private const val SCALE_FIT = 1 private const val ALIGN_CENTER = 0 private const val ALIGN_PICTURE_TOP = 3 diff --git a/app/src/main/java/com/droiddeck/launcher/agent/AgentBridgeProvider.kt b/app/src/main/java/com/droiddeck/launcher/agent/AgentBridgeProvider.kt index 4294e5ad9a..a4322909ad 100644 --- a/app/src/main/java/com/droiddeck/launcher/agent/AgentBridgeProvider.kt +++ b/app/src/main/java/com/droiddeck/launcher/agent/AgentBridgeProvider.kt @@ -92,11 +92,111 @@ class AgentBridgeProvider : ContentProvider() { AgentEnv.override(context, request.optString("name")).put("ok", true).put("command", "override") } "prefs" -> prefs(context, request) + "glasses" -> glasses(context, request) "access" -> JSONObject().put("ok", true).put("commands", AgentAccess.commandsAllowed(context)) .put("debugBuild", BuildConfig.DEBUG).put("inbox", AgentEnv.inbox(context).absolutePath) else -> error("UNKNOWN_COMMAND", "Unknown agent command '$method'") } + private fun glasses(context: Context, request: JSONObject): JSONObject { + val g = com.droiddeck.launcher.glasses.Glasses + when (request.optString("op", "status")) { + "status" -> {} + "allow" -> g.requestControl() + "set" -> { + val key = request.optString("key") + val value = request.optString("value") + fun on() = value == "1" || value.equals("true", true) || value.equals("on", true) + val number = value.toIntOrNull() + val numeric = setOf("refreshHz", "sbsHz", "brightness", "volume", "picture3d", "screenWidthDm", "screenDistanceDm", "vrFovDeg", "sbsSupport", "eyeHeightCm") + if (key in numeric && number == null) return error("INVALID_VALUE", "'$key' takes a number") + when (key) { + "refreshHz" -> g.setRefreshHz(number!!) + "sbsHz" -> g.setSbsHz(number!!) + "resolution2d" -> g.setResolution(com.droiddeck.launcher.glasses.GlassesDisplayProfile.TWO_D, value) + "resolution3d" -> g.setResolution(com.droiddeck.launcher.glasses.GlassesDisplayProfile.THREE_D, value) + "resolutionVr" -> g.setResolution(com.droiddeck.launcher.glasses.GlassesDisplayProfile.VR, value) + "brightness" -> g.setBrightness(number!!) + "volume" -> g.setVolume(number!!) + "sunblock" -> g.setSunblock(on()) + "3d" -> g.set3d(on()) + "3dof" -> g.set3dof(on()) + "gameOnGlasses" -> g.setGameOnGlasses(on()) + "headTracking" -> g.setHeadTracking(on()) + "auto3d" -> g.setAuto3d(on()) + "picture3d" -> g.setPicture3d(number!!) + "screenWidthDm" -> g.setScreenWidthDm(number!!) + "screenDistanceDm" -> g.setScreenDistanceDm(number!!) + "vrFovDeg" -> g.setVrFovDeg(number!!) + "sbsSupport" -> g.setSbsSupport(number!!) + "positionalTracking" -> g.setPositionalTracking(on()) + "handControllers" -> g.setHandControllers(on()) + "joyConTracking" -> g.setJoyConTracking(on()) + "eyeHeightCm" -> g.setEyeHeight(number!!) + else -> return error("INVALID_KEY", "Unknown glasses setting '$key'") + } + } + "simulate" -> { + fun angle(key: String) = if (request.has(key)) request.optDouble(key).takeIf { it.isFinite() }?.coerceIn(-90.0, 90.0) else null + if (!g.simulate(request.optInt("seconds", 20).coerceIn(1, 600), angle("yaw"), angle("pitch"))) return error("BUSY", "Already simulating") + } + "stop-simulate" -> g.stopSimulation() + "calibrate" -> g.startCalibration() + "cancel-calibration" -> g.cancelCalibration() + "reset-calibration" -> g.resetCalibration() + "spatial-diagnostics" -> com.droiddeck.launcher.glasses.SpatialTracking.diagnostics(request.optBoolean("enabled",true)) + "spatial-recenter" -> com.droiddeck.launcher.glasses.SpatialTracking.recenter(request.optBoolean("screen",false)) + "spatial-floor" -> g.setSpatialFloor() + "spatial-restart" -> g.restartSpatialTracking() + "spatial-hand-options" -> { + AgentAccess.requireCommands(context) + if(request.has("lite")) com.droiddeck.launcher.glasses.SpatialTracking.setHandModel(request.getBoolean("lite")) + if(request.has("parallel")) com.droiddeck.launcher.glasses.SpatialTracking.setHandCpuParallel(request.getBoolean("parallel")) + if(request.has("halfRate")) com.droiddeck.launcher.glasses.SpatialTracking.setHandHalfRate(request.getBoolean("halfRate")) + if(request.has("adaptive")) com.droiddeck.launcher.glasses.SpatialTracking.setHandAdaptiveInput(request.getBoolean("adaptive")) + if(request.has("scheduled")) com.droiddeck.launcher.glasses.SpatialTracking.setHandScheduledTracking(request.getBoolean("scheduled")) + } + "spatial-hand-benchmark" -> { + AgentAccess.requireCommands(context) + com.droiddeck.launcher.glasses.SpatialTracking.benchmarkSavedCapture(request.getString("capture")) + } + "spatial-hand-capture" -> { + AgentAccess.requireCommands(context) + com.droiddeck.launcher.glasses.SpatialTracking.captureDiagnostic() + } + "spatial-rgb-capture", "spatial-rgb-status" -> { + AgentAccess.requireCommands(context) + return (if (request.getString("op") == "spatial-rgb-capture") + com.droiddeck.launcher.glasses.LumaRgbDiagnostic.capture(context!!,request.optString("transport","sdk"), + request.optInt("width",640),request.optInt("height",480),request.optInt("fps",30), + request.optInt("durationMs",5000)) + else com.droiddeck.launcher.glasses.LumaRgbDiagnostic.status(context!!)).put("ok", true) + } + "query" -> { g.query(); Thread.sleep(600) } + "mode" -> { + val mode = hex(request.optString("mode"), 0xFF) ?: return error("INVALID_VALUE", "mode must be one hex byte, e.g. 0x31") + g.sendMode(mode) + Thread.sleep(600) + } + "imu" -> return g.sampleImu(request.optLong("ms", 2000).coerceIn(200, 20_000)).put("ok", true).put("command", "glasses") + "raw" -> { + AgentAccess.requireCommands(context) + val msgId = hex(request.optString("msgId"), 0xFFFF) ?: return error("INVALID_VALUE", "msgId must be a hex number up to 0xFFFF") + val digits = request.optString("payload").removePrefix("0x") + if (digits.length % 2 != 0 || digits.any { Character.digit(it, 16) < 0 }) return error("INVALID_VALUE", "payload must be whole hex bytes") + val payload = digits.chunked(2).map { it.toInt(16).toByte() }.toByteArray() + if (!g.sendRaw(msgId, payload)) return error("NOT_CONNECTED", "The glasses' control link is not open") + Thread.sleep(300) + } + else -> return error("INVALID_OP", "Unknown glasses op") + } + if (request.optString("op") in setOf("set", "allow")) Thread.sleep(400) + return g.status().put("ok", true).put("command", "glasses").put("frames", g.recentFrames()) + } + + private fun hex(text: String, max: Int): Int? = + text.removePrefix("0x").removePrefix("0X").takeIf { it.isNotEmpty() }?.toIntOrNull(16)?.takeIf { it in 0..max } + private fun state(context: Context): JSONObject { val runtimeVersion = LinuxRuntimeInstaller.installedVersion(context) val dir = SessionState.logDirectory ?: SessionState.logFile?.parentFile ?: SessionPaths.sessionFolders(context).lastOrNull() @@ -109,6 +209,7 @@ class AgentBridgeProvider : ContentProvider() { .put("steamUi", SessionState.steamUi ?: JSONObject.NULL) .put("steamUrl", SessionState.steamUrl ?: JSONObject.NULL) .put("suspended", SessionState.suspended) + .put("steamVr", SessionState.steamVr) .put("pip", SessionState.pipActive) .put("firstFrame", SessionState.firstFrameSeen) .put("output", JSONArray().put(SessionState.outputSize.first).put(SessionState.outputSize.second)) diff --git a/app/src/main/java/com/droiddeck/launcher/agent/AgentGuest.kt b/app/src/main/java/com/droiddeck/launcher/agent/AgentGuest.kt index 3b265ebb90..2295c407e2 100644 --- a/app/src/main/java/com/droiddeck/launcher/agent/AgentGuest.kt +++ b/app/src/main/java/com/droiddeck/launcher/agent/AgentGuest.kt @@ -136,8 +136,12 @@ object AgentGuest { return null } - fun call(context: Context, request: JSONObject, timeoutMs: Long): JSONObject { - if (request.optString("kind") in setOf("exec", "cdp")) AgentAccess.requireCommands(context) + fun steamEval(context: Context, expression: String, timeoutMs: Long): JSONObject = + call(context, JSONObject().put("kind", "cdp").put("expression", expression).put("timeout", timeoutMs / 1000.0), + timeoutMs + 2_000, trusted = true) + + fun call(context: Context, request: JSONObject, timeoutMs: Long, trusted: Boolean = false): JSONObject { + if (!trusted && request.optString("kind") in setOf("exec", "cdp")) AgentAccess.requireCommands(context) if (!SessionState.running) throw AgentException("NO_ACTIVE_SESSION", "There is no running session") hello(context) ?: throw AgentException("AGENT_UNAVAILABLE", "The guest agent is not running in this session (yet)") val dir = dir(context) diff --git a/app/src/main/java/com/droiddeck/launcher/agent/AgentStartActivity.kt b/app/src/main/java/com/droiddeck/launcher/agent/AgentStartActivity.kt index 9b9d85bbd8..f052df93cf 100644 --- a/app/src/main/java/com/droiddeck/launcher/agent/AgentStartActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/agent/AgentStartActivity.kt @@ -97,6 +97,7 @@ class AgentStartActivity : Activity() { request.optString("steamUrl").takeIf { it.startsWith("steam://") }?.let { putExtra(SessionService.EXTRA_STEAM_URL, it) } + if (request.optBoolean("steamVr")) putExtra(SessionActivity.EXTRA_STEAMVR, true) } } startActivity(sessionIntent) 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 725fffeb99..fedf9d64f3 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/DeviceReport.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/DeviceReport.kt @@ -2,12 +2,17 @@ package com.droiddeck.launcher.core import android.app.ActivityManager import android.content.Context +import android.hardware.display.DisplayManager import android.os.Build import android.os.Environment +import android.os.PerformanceHintManager +import android.os.PowerManager import android.os.StatFs +import android.provider.Settings import android.util.Log import com.droiddeck.launcher.gpu.DeviceInfo import com.droiddeck.launcher.gpu.SystemVulkanDriver +import android.view.Display import com.droiddeck.launcher.gpu.LinuxVulkanDriver import com.droiddeck.launcher.gpu.LinuxVulkanDriverManager import com.droiddeck.launcher.gpu.TurnipDriver @@ -34,6 +39,57 @@ object DeviceReport { } } + /** Name of an ApplicationExitInfo reason code, so a report says "LOW_MEMORY" instead of "3". */ + internal fun exitReasonName(reason: Int): String = when (reason) { + 0 -> "UNKNOWN" + 1 -> "EXIT_SELF" + 2 -> "SIGNALED" + 3 -> "LOW_MEMORY" + 4 -> "CRASH" + 5 -> "CRASH_NATIVE" + 6 -> "ANR" + 7 -> "INITIALIZATION_FAILURE" + 8 -> "PERMISSION_CHANGE" + 9 -> "EXCESSIVE_RESOURCE_USAGE" + 10 -> "USER_REQUESTED" + 11 -> "USER_STOPPED" + 12 -> "DEPENDENCY_DIED" + 13 -> "OTHER" + 14 -> "FREEZER" + 15 -> "PACKAGE_STATE_CHANGE" + 16 -> "PACKAGE_UPDATED" + else -> "REASON_$reason" + } + + internal fun thermalStatusName(status: Int): String = when (status) { + 0 -> "NONE" + 1 -> "LIGHT" + 2 -> "MODERATE" + 3 -> "SEVERE" + 4 -> "CRITICAL" + 5 -> "EMERGENCY" + 6 -> "SHUTDOWN" + else -> "STATUS_$status" + } + + internal fun gameModeName(mode: Int): String = when (mode) { + 0 -> "UNSUPPORTED" + 1 -> "STANDARD" + 2 -> "PERFORMANCE" + 3 -> "BATTERY" + 4 -> "CUSTOM" + else -> "MODE_$mode" + } + + internal fun refreshModesSummary(rates: List): String = + rates.map { Math.round(it) }.distinct().sortedDescending().joinToString(", ") { "$it Hz" } + + internal fun exitSummary(processName: String?, reason: Int, status: Int, description: String?): String = + buildString { + append(processName ?: "?").append(" ").append(exitReasonName(reason)).append(" status=").append(status) + if (!description.isNullOrBlank()) append(" ").append(description.trim()) + } + fun build(context: Context, mode: String): String { val b = StringBuilder() fun h(title: String) { @@ -71,6 +127,20 @@ object DeviceReport { k("Fingerprint", Build.FINGERPRINT) k("Kernel", System.getProperty("os.version")) k("ABIs", Build.SUPPORTED_ABIS.joinToString(", ")) + k("Memory page size", runCatching { android.system.Os.sysconf(android.system.OsConstants._SC_PAGESIZE) }.getOrNull()?.let { "$it bytes" }) + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) { + h("Recent process exits") + val exits = runCatching { + context.getSystemService(android.app.ActivityManager::class.java).getHistoricalProcessExitReasons(context.packageName, 0, 5) + }.getOrNull().orEmpty() + if (exits.isEmpty()) k("Exits", "none recorded") else { + val stamp = SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US) + for (e in exits) { + k(stamp.format(Date(e.timestamp)), exitSummary(e.processName, e.reason, e.status, e.description)) + } + } + } h("CPU and memory") k("Cores", CpuCores.all.size) @@ -85,6 +155,19 @@ object DeviceReport { k("RAM total", FileUtils.sizeToString(mi.totalMem)) k("RAM available", FileUtils.sizeToString(mi.availMem)) } + runCatching { + val pm = context.getSystemService(Context.POWER_SERVICE) as PowerManager + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) k("Thermal status", thermalStatusName(pm.currentThermalStatus)) + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) { + k("Thermal headroom (10 s)", pm.getThermalHeadroom(10).let { if (it.isNaN()) "not reported" else String.format(Locale.US, "%.2f", it) }) + } + k("Power saver", pm.isPowerSaveMode) + } + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { + val rate = runCatching { context.getSystemService(PerformanceHintManager::class.java)?.preferredUpdateRateNanos }.getOrNull() + k("ADPF hint sessions", if (rate == null || rate <= 0) "not supported" else "supported (preferred update ${rate / 1000} us)") + k("Game Mode", runCatching { context.getSystemService(android.app.GameManager::class.java)?.gameMode }.getOrNull()?.let { gameModeName(it) }) + } runCatching { val fs = StatFs(context.filesDir.path) k("App storage free", FileUtils.sizeToString(fs.availableBlocksLong * fs.blockSizeLong)) @@ -106,6 +189,13 @@ object DeviceReport { h("Display") k("Session output", SessionState.outputSize?.let { "${it.first}x${it.second}" }) k("Session refresh", String.format(Locale.US, "%.2f Hz", SessionState.refreshHz)) + runCatching { + val display = context.getSystemService(DisplayManager::class.java).getDisplay(Display.DEFAULT_DISPLAY) + k("Panel refresh now", String.format(Locale.US, "%.2f Hz", display.refreshRate)) + k("Panel refresh modes", refreshModesSummary(display.supportedModes.map { it.refreshRate })) + } + k("peak_refresh_rate", runCatching { Settings.System.getString(context.contentResolver, "peak_refresh_rate") }.getOrNull() ?: "not set") + k("refresh_rate_mode", runCatching { Settings.Secure.getString(context.contentResolver, "refresh_rate_mode") }.getOrNull() ?: "not set") val panelSize = com.droiddeck.launcher.session.SessionDisplay.panelSize(context) for ((label, mode) in listOf("Resolution (Steam)" to SessionService.MODE_STEAM, "Resolution (Desktop)" to SessionService.MODE_DESKTOP)) { val choice = SessionPrefs.resolutionChoice(context, mode, panelSize) diff --git a/app/src/main/java/com/droiddeck/launcher/core/DownloadSource.kt b/app/src/main/java/com/droiddeck/launcher/core/DownloadSource.kt new file mode 100644 index 0000000000..a613bf614f --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/core/DownloadSource.kt @@ -0,0 +1,207 @@ +package com.droiddeck.launcher.core + +import android.content.Context +import android.content.SharedPreferences +import java.net.HttpURLConnection +import java.net.URL +import java.util.concurrent.ConcurrentHashMap +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit +import java.util.concurrent.atomic.AtomicBoolean +import java.util.concurrent.atomic.AtomicLong + +object DownloadSource { + const val MODE_AUTO = "auto" + const val MODE_DIRECT = "direct" + const val MODE_MIRROR = "mirror" + const val MODE_CUSTOM = "custom" + + private const val PREFS = "download-source" + private const val KEY_MODE = "mode" + private const val KEY_MIRROR = "mirror" + private const val KEY_CUSTOM = "custom" + private const val KEY_FASTEST = "fastest" + + private const val PROBE = "https://raw.githubusercontent.com/Droid-Deck/DroidDeck/main/README.md" + private const val PROBE_TIMEOUT_MS = 4_000 + private const val PROBE_COOLDOWN_MS = 30_000L + private const val UA = "DroidDeck-Android" + + private val MODES = listOf(MODE_AUTO, MODE_DIRECT, MODE_MIRROR, MODE_CUSTOM) + + private val GITHUB_HOSTS = listOf( + "github.com", + "raw.githubusercontent.com", + "api.github.com", + ) + + private val CATALOGS = listOf( + "https://raw.githubusercontent.com/Droid-Deck/DroidDeck-CI/", + "https://raw.githubusercontent.com/Droid-Deck/DroidDeck-Components/", + ) + + data class Mirror(val host: String, val api: Boolean) + + val MIRRORS = listOf( + Mirror("gh-proxy.com", true), + Mirror("gh-proxy.org", true), + Mirror("ghproxy.net", false), + Mirror("ghfast.top", false), + ) + + @Volatile + private var app: Context? = null + + @Volatile + private var lastGood: String? = null + + private val probing = AtomicBoolean(false) + private val probedAt = AtomicLong(0L) + + fun init(context: Context) { + app = context.applicationContext + lastGood = prefs()?.getString(KEY_FASTEST, null) + } + + fun probe() { + if (app == null || prefs()?.getString(KEY_MODE, MODE_AUTO) == MODE_DIRECT) return + if (!probing.compareAndSet(false, true)) return + val now = System.currentTimeMillis() + if (now - probedAt.get() < PROBE_COOLDOWN_MS) { + probing.set(false) + return + } + probedAt.set(now) + Thread { + try { + val times = ConcurrentHashMap() + val sources = listOf(null) + MIRRORS.map { it.host } + val latch = CountDownLatch(sources.size) + for (mirror in sources) { + Thread { + try { + val ms = latency(mirror?.let { "https://$it/$PROBE" } ?: PROBE) + if (ms > 0) times[mirror ?: ""] = ms + } finally { + latch.countDown() + } + }.apply { isDaemon = true }.start() + } + latch.await(PROBE_TIMEOUT_MS * 3L, TimeUnit.MILLISECONDS) + val best = times.minByOrNull { it.value }?.key ?: return@Thread + lastGood = best + prefs()?.edit()?.putString(KEY_FASTEST, best)?.apply() + } finally { + probing.set(false) + } + }.apply { isDaemon = true }.start() + } + + private fun latency(url: String): Long { + val started = System.nanoTime() + var connection: HttpURLConnection? = null + return try { + val c = (URL(url).openConnection() as HttpURLConnection).apply { + connectTimeout = PROBE_TIMEOUT_MS + readTimeout = PROBE_TIMEOUT_MS + instanceFollowRedirects = true + setRequestProperty("Range", "bytes=0-1023") + setRequestProperty("User-Agent", UA) + } + connection = c + if (c.responseCode / 100 != 2) 0L else { + c.inputStream.use { it.read() } + (System.nanoTime() - started) / 1_000_000 + } + } catch (e: Exception) { + 0L + } finally { + runCatching { connection?.disconnect() } + } + } + + fun isGithub(url: String): Boolean = GITHUB_HOSTS.any { url.startsWith("https://$it/") } + + /** Catalogs carry the digests everything else is checked against, so a mirror must never supply one. */ + fun isCatalog(url: String): Boolean = CATALOGS.any { url.startsWith(it) } + + fun candidates(target: String): List { + // GitHub API metadata carries executable URLs and digests; never proxy it. + if (isCatalog(target) || target.startsWith("https://api.github.com/")) return listOf(target) + val prefs = prefs() ?: return listOf(target) + if (!isGithub(target)) return listOf(target) + val api = target.startsWith("https://api.github.com/") + val proxies = MIRRORS.filter { !api || it.api }.map { it.proxy(target) } + val ordered = when (prefs.getString(KEY_MODE, MODE_AUTO) ?: MODE_AUTO) { + MODE_DIRECT -> listOf(target) + MODE_MIRROR -> listOfNotNull(picked(prefs, api)?.proxy(target)) + listOf(target) + quickest(proxies) + MODE_CUSTOM -> listOfNotNull(customProxy(prefs, target)) + listOf(target) + quickest(proxies) + else -> if (api) listOf(target) else listOf(target) + quickest(proxies) + } + return ordered.distinct() + } + + private fun quickest(sources: List): List = + sources.sortedBy { if (host(it) == lastGood) 0 else 1 } + + fun succeeded(source: String) { + lastGood = host(source) + } + + fun failed() { + lastGood = null + prefs()?.edit()?.remove(KEY_FASTEST)?.apply() + } + + fun mode(context: Context): String = prefs(context)?.getString(KEY_MODE, MODE_AUTO) ?: MODE_AUTO + + fun setMode(context: Context, mode: String) { + prefs(context)?.edit()?.putString(KEY_MODE, mode.takeIf { it in MODES } ?: MODE_AUTO)?.apply() + } + + fun mirror(context: Context): String { + val host = prefs(context)?.getString(KEY_MIRROR, "") ?: "" + return MIRRORS.firstOrNull { it.host == host }?.host ?: MIRRORS.first().host + } + + fun setMirror(context: Context, host: String) { + prefs(context)?.edit()?.putString(KEY_MIRROR, host.takeIf { h -> MIRRORS.any { it.host == h } } ?: "")?.apply() + } + + fun custom(context: Context): String = prefs(context)?.getString(KEY_CUSTOM, "") ?: "" + + fun setCustom(context: Context, prefix: String) { + prefs(context)?.edit()?.putString(KEY_CUSTOM, normalizePrefix(prefix))?.apply() + } + + fun reset(context: Context) { + lastGood = null + prefs(context)?.edit()?.clear()?.apply() + } + + private fun prefs(): SharedPreferences? = app?.getSharedPreferences(PREFS, Context.MODE_PRIVATE) + + private fun prefs(context: Context): SharedPreferences? = + context.applicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE) + + private fun Mirror.proxy(target: String): String = "https://$host/$target" + + private fun host(url: String): String = + MIRRORS.firstOrNull { url.startsWith("https://${it.host}/") }?.host ?: "" + + private fun picked(prefs: SharedPreferences, api: Boolean): Mirror? { + val chosen = MIRRORS.firstOrNull { it.host == (prefs.getString(KEY_MIRROR, "") ?: "") } ?: MIRRORS.firstOrNull() + return if (api && chosen != null && !chosen.api) MIRRORS.firstOrNull { it.api } else chosen + } + + private fun custom(prefs: SharedPreferences): String = prefs.getString(KEY_CUSTOM, "") ?: "" + + private fun customProxy(prefs: SharedPreferences, target: String): String? = + normalizePrefix(custom(prefs)).takeIf { it.isNotEmpty() }?.let { "$it/$target" } + + private fun normalizePrefix(value: String): String { + val trimmed = value.trim().trimEnd('/') + if (trimmed.isEmpty() || trimmed.startsWith("http://")) return "" + return if (trimmed.startsWith("https://")) trimmed else "https://$trimmed" + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/core/Downloader.java b/app/src/main/java/com/droiddeck/launcher/core/Downloader.java index 81ddb9c927..2527c57e82 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/Downloader.java +++ b/app/src/main/java/com/droiddeck/launcher/core/Downloader.java @@ -6,69 +6,201 @@ import java.io.BufferedInputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileOutputStream; +import java.io.FileInputStream; +import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.HttpURLConnection; import java.net.URL; import java.nio.charset.StandardCharsets; +import java.util.List; +import java.util.Properties; public final class Downloader { private static final String TAG = "Downloader"; - private static final int TIMEOUT_MS = 30_000; + private static final int CONNECT_TIMEOUT_MS = 10_000; + private static final int STALL_TIMEOUT_MS = 15_000; + private static final int HTTP_RANGE_NOT_SATISFIABLE = 416; private Downloader() {} public static String downloadString(String url) { - HttpURLConnection connection = null; - try { - connection = open(url); - if (connection.getResponseCode() / 100 != 2) { - Log.w(TAG, url + " -> HTTP " + connection.getResponseCode()); - return null; + List sources = DownloadSource.INSTANCE.candidates(url); + for (int i = 0; i < sources.size(); i++) { + if (i > 0) Log.i(TAG, "retrying " + url + " via " + sources.get(i)); + Fetch fetch = fetch(sources.get(i)); + if (fetch.body != null) { + DownloadSource.INSTANCE.succeeded(sources.get(i)); + return fetch.body; } - try (InputStream in = connection.getInputStream(); - ByteArrayOutputStream out = new ByteArrayOutputStream()) { - FileUtils.copy(in, out); - return new String(out.toByteArray(), StandardCharsets.UTF_8); - } - } catch (Exception e) { - Log.w(TAG, "GET " + url, e); - return null; - } finally { - if (connection != null) connection.disconnect(); + if (fetch.fatal && sources.get(i).equals(url)) return null; } + DownloadSource.INSTANCE.failed(); + return null; + } + + /** Fetches without the mirror list, for a URL whose body is a digest the payload is checked against. */ + public static String downloadDirect(String url) { + return fetch(url).body; } public static boolean downloadFile(String url, File destination, boolean resume, java.util.function.Consumer progress) { + return downloadFile(url, destination, resume, null, progress); + } + + /** Verify each candidate before accepting it, so a bad mirror can fall back. */ + public static boolean downloadFile(String url, File destination, boolean resume, String expectedSha256, + java.util.function.Consumer progress) { + if (expectedSha256 != null && !expectedSha256.matches("(?i)[0-9a-f]{64}")) + throw new IllegalArgumentException("Expected SHA-256 must be 64 hex characters"); + return downloadCandidates(url, DownloadSource.INSTANCE.candidates(url), destination, resume, expectedSha256, progress); + } + + // Package-private for the local multi-source HTTP test. + static boolean downloadCandidates(String original, List sources, File destination, boolean resume, + String expectedSha256, java.util.function.Consumer progress) { + Identity identity = loadIdentity(destination, resume, expectedSha256); + for (int i = 0; i < sources.size(); i++) { + String source = sources.get(i); + if (i > 0) Log.i(TAG, "retrying " + original + " via " + source); + Outcome outcome = attempt(source, destination, resume, identity, expectedSha256, progress); + if (outcome == Outcome.DONE) { + if (expectedSha256 != null && !expectedSha256.equalsIgnoreCase(Hashes.sha256(destination))) { + Log.w(TAG, "checksum mismatch from " + source + "; trying another source"); + if (!discardPartial(destination, identity)) return false; + continue; + } + resumeFile(destination).delete(); + DownloadSource.INSTANCE.succeeded(source); + if (progress != null) progress.accept(1f); + return true; + } + if (outcome == Outcome.FATAL && source.equals(original)) return false; + } + DownloadSource.INSTANCE.failed(); + return false; + } + + private enum Outcome { DONE, RETRY, FATAL } + + private static final class Identity { + private String source; + private String etag; + } + + private static File resumeFile(File dest) { + return new File(dest.getPath() + ".resume.properties"); + } + + private static boolean strongETag(String value) { + return value != null && !value.isEmpty() && !value.startsWith("W/"); + } + + /** Only reuse saved bytes when we persisted a strong validator and their source. */ + private static Identity loadIdentity(File dest, boolean resume, String expectedSha256) { + Identity identity = new Identity(); + File marker = resumeFile(dest); + if (!resume || !dest.isFile() || dest.length() == 0) { + marker.delete(); + return identity; + } + try (FileInputStream in = new FileInputStream(marker)) { + Properties p = new Properties(); + p.load(in); + String source = p.getProperty("source"); + String etag = p.getProperty("etag"); + String expected = p.getProperty("sha256", ""); + if (source != null && source.startsWith("http") && strongETag(etag) + && expected.equals(expectedSha256 == null ? "" : expectedSha256.toLowerCase(java.util.Locale.ROOT))) { + identity.source = source; + identity.etag = etag; + return identity; + } + } catch (IOException e) { + // Legacy partials or interrupted metadata writes have no trustworthy identity. + } + if (!discardPartial(dest, identity)) Log.w(TAG, "could not discard unidentified partial " + dest); + return identity; + } + + private static boolean discardPartial(File dest, Identity identity) { + identity.source = null; + identity.etag = null; + File marker = resumeFile(dest); + return (!dest.exists() || dest.delete()) && (!marker.exists() || marker.delete()); + } + + private static void saveIdentity(File dest, Identity identity, String expectedSha256) { + File marker = resumeFile(dest); + if (!strongETag(identity.etag)) { + marker.delete(); + return; + } + Properties p = new Properties(); + p.setProperty("source", identity.source); + p.setProperty("etag", identity.etag); + p.setProperty("sha256", expectedSha256 == null ? "" : expectedSha256.toLowerCase(java.util.Locale.ROOT)); + try (FileOutputStream out = new FileOutputStream(marker)) { + p.store(out, "DroidDeck partial download validator"); + } catch (IOException e) { + marker.delete(); // No valid metadata means no future resume. + Log.w(TAG, "cannot persist download validator", e); + } + } + + private static Outcome attempt(String url, File destination, boolean resume, Identity identity, + String expectedSha256, java.util.function.Consumer progress) { HttpURLConnection connection = null; long have = resume && destination.isFile() ? destination.length() : 0; try { - connection = open(url); - if (have > 0) connection.setRequestProperty("Range", "bytes=" + have + "-"); + if (have > 0 && (!url.equals(identity.source) || !strongETag(identity.etag))) { + // A new source or unvalidated bytes must restart from byte zero. + if (!discardPartial(destination, identity)) return Outcome.RETRY; + have = 0; + } + connection = open(url, STALL_TIMEOUT_MS); + if (have > 0) { + connection.setRequestProperty("Range", "bytes=" + have + "-"); + connection.setRequestProperty("If-Range", identity.etag); + } int code = connection.getResponseCode(); - boolean appending = code == HttpURLConnection.HTTP_PARTIAL; - if (appending && !rangeStartsAt(connection.getHeaderField("Content-Range"), have)) { - // A 206 that does not begin where the kept bytes end would corrupt the file if appended. + if (have > 0 && code == HTTP_RANGE_NOT_SATISFIABLE) { connection.disconnect(); - destination.delete(); - return downloadFile(url, destination, false, progress); + if (!discardPartial(destination, identity)) return Outcome.RETRY; + return attempt(url, destination, false, identity, expectedSha256, progress); } if (code / 100 != 2) { - if (have > 0) { - connection.disconnect(); - destination.delete(); - return downloadFile(url, destination, false, progress); - } Log.w(TAG, url + " -> HTTP " + code); - return false; + return code == HttpURLConnection.HTTP_NOT_FOUND || code == HttpURLConnection.HTTP_GONE + ? Outcome.FATAL : Outcome.RETRY; + } + boolean appending = code == HttpURLConnection.HTTP_PARTIAL; + if (appending && !rangeStartsAt(connection.getHeaderField("Content-Range"), have)) { + connection.disconnect(); + if (!discardPartial(destination, identity)) return Outcome.RETRY; + return attempt(url, destination, false, identity, expectedSha256, progress); + } + String etag = connection.getHeaderField("ETag"); + if (have > 0 && appending && (!strongETag(etag) || !etag.equals(identity.etag))) { + connection.disconnect(); + if (!discardPartial(destination, identity)) return Outcome.RETRY; + return attempt(url, destination, false, identity, expectedSha256, progress); + } + if (!appending && have > 0) { + // If-Range may legitimately return full 200 when representation changed. + if (!discardPartial(destination, identity)) return Outcome.RETRY; + have = 0; } if (!appending) have = 0; long length = connection.getContentLengthLong(); - long total = length < 0 ? -1 : length + have; + long total = appending ? rangeTotal(connection.getHeaderField("Content-Range")) : -1; + if (total < 0) total = length < 0 ? -1 : length + have; File parent = destination.getParentFile(); - if (parent != null && !parent.isDirectory()) - parent.mkdirs(); + if (parent != null && !parent.isDirectory()) parent.mkdirs(); + identity.source = url; + identity.etag = strongETag(etag) ? etag : null; + saveIdentity(destination, identity, expectedSha256); long written = have; try (InputStream in = new BufferedInputStream(connection.getInputStream(), 1 << 16); OutputStream out = new FileOutputStream(destination, appending)) { @@ -83,11 +215,11 @@ public final class Downloader { } } } - if (progress != null) progress.accept(1f); - return total <= 0 || written >= total; + if (total > 0 && written < total) return Outcome.RETRY; + return Outcome.DONE; } catch (Exception e) { Log.w(TAG, "download " + url, e); - return false; + return Outcome.RETRY; } finally { if (connection != null) connection.disconnect(); } @@ -100,10 +232,49 @@ public final class Downloader { return m.matches() && Long.parseLong(m.group(1)) == start; } - private static HttpURLConnection open(String url) throws java.io.IOException { + /** The complete length in a `Content-Range` header, or -1 when the header leaves it unknown. */ + static long rangeTotal(String contentRange) { + if (contentRange == null) return -1; + java.util.regex.Matcher m = java.util.regex.Pattern.compile("^\\s*bytes\\s+\\d+-\\d+/(\\d+)\\s*$").matcher(contentRange); + return m.matches() ? Long.parseLong(m.group(1)) : -1; + } + + private static final class Fetch { + final String body; + final boolean fatal; + + Fetch(String body, boolean fatal) { + this.body = body; + this.fatal = fatal; + } + } + + private static Fetch fetch(String url) { + HttpURLConnection connection = null; + try { + connection = open(url, STALL_TIMEOUT_MS); + int code = connection.getResponseCode(); + if (code / 100 != 2) { + Log.w(TAG, url + " -> HTTP " + code); + return new Fetch(null, code == HttpURLConnection.HTTP_NOT_FOUND || code == HttpURLConnection.HTTP_GONE); + } + try (InputStream in = connection.getInputStream(); + ByteArrayOutputStream out = new ByteArrayOutputStream()) { + FileUtils.copy(in, out); + return new Fetch(new String(out.toByteArray(), StandardCharsets.UTF_8), false); + } + } catch (Exception e) { + Log.w(TAG, "GET " + url, e); + return new Fetch(null, false); + } finally { + if (connection != null) connection.disconnect(); + } + } + + private static HttpURLConnection open(String url, int readTimeoutMs) throws java.io.IOException { HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection(); - connection.setConnectTimeout(TIMEOUT_MS); - connection.setReadTimeout(TIMEOUT_MS); + connection.setConnectTimeout(CONNECT_TIMEOUT_MS); + connection.setReadTimeout(readTimeoutMs); connection.setInstanceFollowRedirects(true); connection.setRequestProperty("User-Agent", "DroidDeck-Android"); return connection; diff --git a/app/src/main/java/com/droiddeck/launcher/core/GameEnvironment.kt b/app/src/main/java/com/droiddeck/launcher/core/GameEnvironment.kt index 045b52ed45..c8341afc26 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/GameEnvironment.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/GameEnvironment.kt @@ -1,5 +1,7 @@ package com.droiddeck.launcher.core +import com.droiddeck.launcher.session.SessionPrefs + object GameEnvironment { data class Config( val shared: Map = emptyMap(), @@ -83,4 +85,34 @@ object GameEnvironment { } const val CUSTOM_FEX_PRESET = "__custom__" + + val syncBackends = listOf(SessionPrefs.SYNC_NTSYNC, SessionPrefs.SYNC_FSYNC, SessionPrefs.SYNC_ESYNC, SessionPrefs.SYNC_WINESERVER) + + val syncKeys = listOf("BL_SYNC", "BL_FSYNC_FIRST", "BL_SYNC_FALLBACK", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC", "PROTON_NO_NTSYNC", "WINEESYNC") + + fun syncEnvironment(backend: String): Map { + require(backend in syncBackends) { "unknown sync $backend" } + return buildMap { + put("BL_SYNC", if (backend == SessionPrefs.SYNC_NTSYNC) "1" else "0") + put("BL_FSYNC_FIRST", if (backend == SessionPrefs.SYNC_FSYNC) "1" else "0") + put("BL_SYNC_FALLBACK", if (backend == SessionPrefs.SYNC_WINESERVER) "0" else "1") + if (backend == SessionPrefs.SYNC_FSYNC) put("PROTON_NO_ESYNC", "1") + } + } + + fun gameSync(config: Config, scope: String): String? { + require(scope.isNotEmpty() && validScope(scope)) + val entries = config.games[scope].orEmpty().filterKeys { it in syncKeys } + if (entries.isEmpty()) return null + return syncBackends.firstOrNull { entries == syncEnvironment(it) } ?: CUSTOM_SYNC + } + + fun withGameSync(config: Config, scope: String, backend: String?): Config { + require(scope.isNotEmpty() && validScope(scope)) + val entries = config.entries(scope).filterKeys { it !in syncKeys }.toMutableMap() + if (backend != null) entries += syncEnvironment(backend) + return config.withEntries(scope, entries) + } + + const val CUSTOM_SYNC = "__custom__" } diff --git a/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt b/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt index 9694426315..d2128476ac 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt @@ -51,25 +51,29 @@ object LogRedactor { @Volatile private var accounts: List = emptyList() - fun learnAccounts(loginUsers: java.io.File) { - val found = ArrayList() - try { - if (loginUsers.isFile) { - val kv = Regex("\"(AccountName|PersonaName)\"\\s+\"([^\"]*)\"") - kv.findAll(loginUsers.readText()).map { it.groupValues[2].trim() }.filter { it.length >= 3 }.distinct().forEach { name -> - val needs = name.lowercase().takeIf { name.all { it.code < 0x80 } } - found += Learned(Regex("(?i)(?() + val kv = Regex("\"(AccountName|PersonaName)\"\\s+\"([^\"]*)\"") + var unread = false + for (file in loginUsers) { + if (!file.isFile) continue + val text = try { file.readText() } catch (e: Exception) { unread = true; continue } + kv.findAll(text).map { it.groupValues[2].trim() }.filter { it.length >= 3 }.forEach { names += it } } - accounts = found + val learned = names.map { name -> + val needs = name.lowercase().takeIf { name.all { it.code < 0x80 } } + Learned(Regex("(?i)(? listOf( "device_config delete activity_manager max_phantom_processes", "device_config set_sync_disabled_for_tests none", + "settings put global $SETTING true", ) usesDeviceConfig(sdk) -> listOf( "device_config set_sync_disabled_for_tests persistent", "device_config put activity_manager max_phantom_processes $MAX_PHANTOM", + "settings put global $SETTING false", ) else -> listOf("settings put global $SETTING ${if (enabled) "true" else "false"}") } @@ -57,7 +59,12 @@ object PhantomProcessLimit { if (sdk < Build.VERSION_CODES.S) return PhantomProcessStatus.NOT_APPLICABLE if (usesDeviceConfig(sdk)) { val off = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).getBoolean(PREF_ANDROID_12_OFF, false) - return if (off) PhantomProcessStatus.DISABLED else PhantomProcessStatus.UNREADABLE + val global = try { + Settings.Global.getString(context.contentResolver, SETTING) + } catch (_: Exception) { + null + } + return android12Status(off, global, systemProperty(OVERRIDE_PROPERTY)) } val global = try { Settings.Global.getString(context.contentResolver, SETTING) @@ -67,6 +74,10 @@ object PhantomProcessLimit { return status(global, systemProperty(OVERRIDE_PROPERTY)) } + fun android12Status(rememberedOff: Boolean, global: String?, override: String?): PhantomProcessStatus = + if (rememberedOff || status(global, override) == PhantomProcessStatus.DISABLED) PhantomProcessStatus.DISABLED + else PhantomProcessStatus.UNREADABLE + fun status(global: String?, override: String?): PhantomProcessStatus { val value = global?.trim()?.lowercase()?.takeIf { it.isNotEmpty() } ?: override?.trim()?.lowercase()?.takeIf { it.isNotEmpty() } 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 965a4950d8..9ba5c2f6ff 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/SessionLogCapture.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/SessionLogCapture.kt @@ -4,6 +4,7 @@ import android.os.Process import android.util.Log import java.io.BufferedWriter import java.io.File +import java.io.FileOutputStream object SessionLogCapture { private const val TAG = "SessionLogCapture" @@ -11,6 +12,7 @@ object SessionLogCapture { private var pid = -1 private var writer: BufferedWriter? = null private var target: File? = null + private var syncer: Thread? = null @Synchronized fun start(target: File) { @@ -37,6 +39,7 @@ object SessionLogCapture { out.write("logcat could not be started; this ROM may not hand an app its own entries.\n") out.flush() } + target.parentFile?.let { syncer = startSyncing(it) } Log.i(TAG, "app log -> $target (logcat pid $pid)") } catch (e: Exception) { Log.w(TAG, "could not start the app log", e) @@ -49,8 +52,19 @@ object SessionLogCapture { if (t.parentFile?.absolutePath == dir.absolutePath) stop() } + /** flush() only reaches the page cache, and a hard reset on f2fs lost the last minutes of every + * log. Every 2 s the session folder's files (ours and the native parts') are synced to storage. */ + private fun startSyncing(dir: File): Thread = Thread({ + while (true) { + try { Thread.sleep(2000) } catch (e: InterruptedException) { break } + dir.listFiles()?.forEach { runCatching { FileOutputStream(it, true).use { s -> s.fd.sync() } } } + } + }, "session-log-sync").apply { isDaemon = true; start() } + @Synchronized fun stop() { + syncer?.interrupt() + syncer = null target = null if (pid != -1) { try { diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt index efff05c8a7..b3bdeb9684 100644 --- a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt +++ b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt @@ -22,7 +22,7 @@ object AddedGameArt { } enum class Slot(val key: String, val cacheName: String, val assetType: Int?) { - COVER("p", "p.jpg", 0), BACKGROUND("hero", "hero.jpg", 1), LOGO("logo", "logo.png", 2), ICON("icon", "icon.png", null), + COVER("p", "p.jpg", 0), WIDE("header", "header.jpg", 3), BACKGROUND("hero", "hero.jpg", 1), LOGO("logo", "logo.png", 2), ICON("icon", "icon.png", null), } const val FOLDER = "folder" @@ -40,10 +40,10 @@ object AddedGameArt { class Found(val items: List, val status: SteamGridDb.Status) - private val CHOSEN = Regex("""chosen-(\w+)\.(\w+)""") + private val CHOSEN = Regex("""chosen-(p|header|hero|logo|icon)(?:-\d+)?\.(\w+)""") - private fun chosen(cache: File, slot: Slot): File? = - cache.listFiles { f -> CHOSEN.matchEntire(f.name)?.groupValues?.get(1) == slot.key }?.firstOrNull() + internal fun chosen(cache: File, slot: Slot): File? = + cache.listFiles { f -> CHOSEN.matchEntire(f.name)?.groupValues?.get(1) == slot.key }?.maxWithOrNull(compareBy({ it.lastModified() }, { it.name })) private val IMAGE = listOf("png", "jpg", "jpeg") private val PORTRAIT = listOf("cover", "poster", "grid", "boxart", "capsule", "folder", "library_600x900", "portrait") @@ -79,7 +79,7 @@ object AddedGameArt { fun cached(name: String) = File(cache, name).takeIf { it.isFile } return Art( portrait = chosen(cache, Slot.COVER) ?: own.portrait ?: cached("p.jpg") ?: exeArt(context, game, cover = true), - header = own.header ?: cached("header.jpg") ?: exeArt(context, game, cover = false), + header = chosen(cache, Slot.WIDE) ?: own.header ?: cached("header.jpg") ?: exeArt(context, game, cover = false), hero = chosen(cache, Slot.BACKGROUND) ?: own.hero ?: cached("hero.jpg"), logo = chosen(cache, Slot.LOGO) ?: own.logo ?: cached("logo.png"), icon = chosen(cache, Slot.ICON) ?: own.icon ?: cached("icon-sgdb.png") ?: exeIcon(context, game), @@ -96,6 +96,7 @@ object AddedGameArt { chosen(cache, slot)?.let { return@map SlotState(slot, it, chosenSource(context, game, slot).first.ifEmpty { FILE }, true) } val auto: Pair? = when (slot) { Slot.COVER -> own.portrait?.let { it to FOLDER } ?: cached("p.jpg") ?: exeArt(context, game, cover = true)?.let { it to EXE } + Slot.WIDE -> own.header?.let { it to FOLDER } ?: cached("header.jpg") ?: exeArt(context, game, cover = false)?.let { it to EXE } Slot.BACKGROUND -> own.hero?.let { it to FOLDER } ?: cached("hero.jpg") Slot.LOGO -> own.logo?.let { it to FOLDER } ?: cached("logo.png") Slot.ICON -> own.icon?.let { it to FOLDER } ?: File(cache, "icon-sgdb.png").takeIf { it.isFile }?.let { it to SGDB } @@ -117,36 +118,37 @@ object AddedGameArt { folderImages(game.folder).forEach { out.add(Option(FOLDER, it.path, it.path)) } val cache = cacheDir(context, game) val steamId = SteamMatch.resolve(context, game.folder.path, game.exe, game.name, legacy = File(cache, "steam-appid")).appId?.toString() - val remote = when (slot) { Slot.COVER -> "library_600x900.jpg"; Slot.BACKGROUND -> "library_hero.jpg"; Slot.LOGO -> "logo.png"; Slot.ICON -> null } - if (steamId != null && remote != null) { - val url = "$CDN$steamId/$remote".takeIf { exists(it) } ?: steamAssetUrl(steamId, remote) - if (url != null) out.add(Option(STEAM, url, url)) - } - var status = SteamGridDb.Status.OK - val key = SteamGridDb.key(context) - if (key.isEmpty()) { - status = SteamGridDb.Status.NO_KEY - } else { - cache.mkdirs() - try { - val gridId = remembered(File(cache, "sgdb-id"), SteamGridDb.keyChangedAt(context), retryMiss = true) { - SteamGridDb.gameId(key, steamId?.toIntOrNull(), game.name)?.toString() - }?.toIntOrNull() - if (gridId == null) status = SteamGridDb.Status.NO_GAME - else SteamGridDb.images(key, gridId, slot, if (slot == Slot.ICON) 3 else 5) - .forEach { (thumb, full) -> out.add(Option(SGDB, thumb, full)) } - } catch (e: Exception) { - Log.w(TAG, "${game.name}: SteamGridDB failed (${e.javaClass.simpleName})") - status = (e as? SteamGridDb.Failed)?.status ?: SteamGridDb.Status.SERVER - } - } + if (steamId != null) steamOption(steamId, slot)?.let { out.add(it) } + val (found, status) = sgdbChoices(context, File(cache, "sgdb-id"), steamId?.toIntOrNull(), game.name, slot) + out.addAll(found) return Choices(out, status) } + internal fun steamOption(steamId: String, slot: Slot): Option? { + val remote = when (slot) { Slot.COVER -> "library_600x900.jpg"; Slot.WIDE -> "header.jpg"; Slot.BACKGROUND -> "library_hero.jpg"; Slot.LOGO -> "logo.png"; Slot.ICON -> null } ?: return null + val url = "$CDN$steamId/$remote".takeIf { exists(it) } ?: steamAssetUrl(steamId, remote) ?: return null + return Option(STEAM, url, url) + } + + internal fun sgdbChoices(context: Context, marker: File, steamId: Int?, name: String, slot: Slot): Pair, SteamGridDb.Status> { + val key = SteamGridDb.key(context) + if (key.isEmpty()) return emptyList