diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index b063bfb07f..0dc1289e59 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -321,6 +321,17 @@ jobs: install -Dm644 tools/mangoapp/mangoapp "$D/usr/local/bin/mangoapp" rm -rf mango-pkgs ls -l "$M" + mkdir -p pw-pkgs + grep -v '^#' tools/pipewire/packages.txt | while read -r sum url; do + [ -n "$url" ] || continue + curl -fsSL --retry 3 -o pw-pkgs/pkg.tar.zst "$url" + echo "$sum pw-pkgs/pkg.tar.zst" | sha256sum -c - + tar --use-compress-program=unzstd -xf pw-pkgs/pkg.tar.zst -C pw-pkgs + rm pw-pkgs/pkg.tar.zst + done + tools/pipewire/assemble.sh pw-pkgs "$D/usr/local/lib/droiddeck-pipewire.tzst" + rm -rf pw-pkgs + ls -l "$D/usr/local/lib/droiddeck-pipewire.tzst" T="$D/usr/local/lib/droiddeck-msitools" mkdir -p "$T" msi-pkgs grep -v '^#' tools/msitools/packages.txt | while read -r sum url; do @@ -478,6 +489,8 @@ jobs: /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 tools/vr/tests/test_pad_controller_config.cpp -o /tmp/test-pad-controller-config + /tmp/test-pad-controller-config 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 diff --git a/README.md b/README.md index 5ead273034..97043973e1 100644 --- a/README.md +++ b/README.md @@ -21,7 +21,7 @@ On Android 14 and newer, before Steam launches, you must turn on **Disable child ## 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. +Use **Setup → Smart glasses** for app-wide virtual-screen settings across DroidDeck menus, launchers, desktop sessions, and games. Supported VITURE, RayNeo, XREAL, and Rokid 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 @@ -49,10 +49,10 @@ Compatibility and performance vary by device; hardware validation is limited. De 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. The registry entries a GOG game's install script (`goggame-.script`) sets are read the way [Heroic Games Launcher](https://github.com/Heroic-Games-Launcher/HeroicGamesLauncher)'s GOG setup (GPL-3.0) reads them. 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, which also starts the arm64 emulator AppImages whose own runtime cannot run its extractor on Android. The Steam client's audio goes through [@The412Banner](https://github.com/The412Banner)'s [DirectAudio](https://github.com/The412Banner/directaudio) PulseAudio sink (LGPL-2.1-or-later), built from `tools/directaudio/sink` with its request size kept to its ring so clients are not asked to queue 100 ms ahead. mmap ring-buffer controller input was developed by ribbit384 ([WinNative #345](https://github.com/WinNative-Emu/WinNative/pull/345)). Why the x86-64 Steam client refused the arm64 client's sign-in was checked by reading Steam's saved token with the `ConnectCache` format from [deadlock-api-ingest](https://github.com/deadlock-api/deadlock-api-ingest). x86 programs that link OpenSSL 3 under FEX use the copy in the [Steam Linux Runtime 4.0](https://gitlab.steamos.cloud/steamrt/steamrt) platform. Hooks written with `WriteProcessMemory` into code [FEX](https://github.com/FEX-Emu/FEX) has translated go through `/proc//mem` again when the kernel refuses `process_vm_writev`, as [Wine](https://gitlab.winehq.org/wine/wine)'s `server/ptrace.c` wrote them before Wine 11. x86 Linux games under FEX get the same `/etc/asound.conf` that [pressure-vessel](https://gitlab.steamos.cloud/steamrt/steam-runtime-tools) writes into the Steam Linux Runtime, so ALSA plays through PulseAudio. Games render with [Mesa](https://gitlab.freedesktop.org/mesa/mesa) Turnip's own per-render-pass choice between tile memory and system memory, while the Steam client keeps `TU_DEBUG=sysmem`; [FEX](https://github.com/FEX-Emu/FEX)'s code disk cache was checked in its source and is already on through Proton. 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. +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). Rokid support follows the Rokid protocol notes in [ar-drivers-rs](https://github.com/badicsalex/ar-drivers-rs) and @badicsalex's [Void Computing write-ups](https://voidcomputing.hu/blog/worse-better-prettier/), and [Monado](https://gitlab.freedesktop.org/monado/monado)'s Rokid driver. 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, Rokid 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). -The Store installs and runs apps with [Flatpak](https://github.com/flatpak/flatpak) (LGPL-2.1). Its sandbox goes through DroidDeck's own bubblewrap shim, which follows how Flatpak hands bwrap its environment. +The Store installs and runs apps with [Flatpak](https://github.com/flatpak/flatpak) (LGPL-2.1). Its sandbox goes through DroidDeck's own bubblewrap shim, which follows how Flatpak hands bwrap its environment. Chromium and Electron apps from Flathub start their browser processes through [zypak](https://github.com/refi64/zypak) by [@refi64](https://github.com/refi64) (BSD-3-Clause); its source was read to see that it always spawns them through Flatpak's spawn portal, which is why DroidDeck starts them directly without Chromium's sandbox instead. diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 87768b8f72..5439940930 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -177,15 +177,6 @@ android:resizeableActivity="true" android:configChanges="orientation|screenSize|screenLayout|smallestScreenSize|keyboard|keyboardHidden|navigation|uiMode|density" /> - - 64 || triton.mapping_size < TRITON_SHARED_OFFSET + TRITON_SHARED_BLOCK_SIZE) return; auto *shared = reinterpret_cast(reinterpret_cast(triton.ring) + TRITON_SHARED_OFFSET); if (__atomic_load_n(&shared->magic, __ATOMIC_ACQUIRE) != TRITON_SHARED_MAGIC) return; + static std::mutex one_at_a_time; + std::lock_guard guard(one_at_a_time); + for (int waited = 0; + static_cast(__atomic_load_n(&shared->output_seq, __ATOMIC_ACQUIRE)) != + __atomic_load_n(&shared->output_ack, __ATOMIC_ACQUIRE) && + __atomic_load_n(&shared->connected, __ATOMIC_ACQUIRE) != 0 && waited < TRITON_OUTPUT_TIMEOUT_MS * 4; + waited++) { + struct timespec interval = {0, 250 * 1000L}; + nanosleep(&interval, nullptr); + } uint64_t seq = __atomic_load_n(&shared->output_seq, __ATOMIC_RELAXED); if (seq & 1) seq++; __atomic_store_n(&shared->output_seq, seq + 1, __ATOMIC_RELEASE); shared->output_feature = feature ? 1 : 0; - shared->output_length = static_cast(size); + shared->output_length = static_cast(size); memcpy(shared->output, data, size); if (size < sizeof(shared->output)) memset(shared->output + size, 0, sizeof(shared->output) - size); __atomic_thread_fence(__ATOMIC_RELEASE); diff --git a/app/src/main/cpp/venc/venc_proto.h b/app/src/main/cpp/venc/venc_proto.h new file mode 100644 index 0000000000..9622577119 --- /dev/null +++ b/app/src/main/cpp/venc/venc_proto.h @@ -0,0 +1,55 @@ +#ifndef DROIDDECK_VENC_PROTO_H +#define DROIDDECK_VENC_PROTO_H + +#include + +/* SOCK_SEQPACKET between the guest's Remote Play hooks and the app: the emulated /dev/video-enc0 and + * MediaCodec encoder, and remote touches. A config carries the buffer memfds (inputs first) as SCM_RIGHTS; + * every frame gets one reply, touches get none. */ + +#define VENC_MAX_BUFFERS 16 + +enum venc_msg { VENC_CONFIG = 1, VENC_FRAME = 2, VENC_DONE = 3, VENC_BITRATE = 4, VENC_TOUCH = 5 }; +enum venc_touch_action { VENC_TOUCH_DOWN = 0, VENC_TOUCH_MOVE = 1, VENC_TOUCH_UP = 2 }; +enum venc_codec { VENC_H264 = 0, VENC_HEVC = 1 }; + +struct venc_config { + uint32_t type; + uint32_t codec; + uint32_t width, height, stride, rows; + uint32_t fps_num, fps_den; + uint32_t bitrate, peak_bitrate, vbr; + uint32_t gop; + int32_t profile, level; + uint32_t inputs, outputs; + uint32_t input_size, output_size; +}; + +struct venc_frame { + uint32_t type; + uint32_t input, output; + uint32_t bytes; + uint32_t keyframe; + int64_t pts_us; +}; + +struct venc_done { + uint32_t type; + int32_t status; + uint32_t bytes; + uint32_t keyframe; +}; + +struct venc_bitrate { + uint32_t type; + uint32_t bitrate; +}; + +/* Remote Play's touch-as-mouse turned back into a touch; x and y are fractions of the screen in 1/65535. */ +struct venc_touch { + uint32_t type; + uint32_t action; + uint32_t x, y; +}; + +#endif diff --git a/app/src/main/cpp/venc/venc_server.cpp b/app/src/main/cpp/venc/venc_server.cpp new file mode 100644 index 0000000000..be484c898d --- /dev/null +++ b/app/src/main/cpp/venc/venc_server.cpp @@ -0,0 +1,346 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "venc_proto.h" + +#define LOG(...) __android_log_print(ANDROID_LOG_INFO, "DroidDeckVenc", __VA_ARGS__) + +namespace { + +struct Mapping { + uint8_t *data = nullptr; + size_t size = 0; +}; + +constexpr int32_t kColorFormatYuv420SemiPlanar = 21; +constexpr uint32_t kBufferFlagKeyFrame = 1; +constexpr uint32_t kBufferFlagCodecConfig = 2; +constexpr int kTouchWidth = 1920, kTouchHeight = 1080; // InputSpace.kt +constexpr int kRemoteTouchId = 31; // the compositor's last touch slot (MAX_TOUCH_POINTS 32) + +int32_t avc_profile(int32_t v4l2) { + switch (v4l2) { + case 0: return 1; + case 1: return 0x10000; + case 2: return 2; + case 3: return 4; + case 4: return 8; + default: return 0; + } +} + +class Session { +public: + explicit Session(int fd) : fd_(fd) {} + ~Session() { + release(); + close(fd_); + } + + void run() { + for (;;) { + uint8_t buf[256]; + int fds[VENC_MAX_BUFFERS * 2]; + int nfds = 0; + ssize_t n = receive(buf, sizeof buf, fds, &nfds); + if (n <= 0) return; + uint32_t type; + memcpy(&type, buf, sizeof type); + if (type == VENC_CONFIG && n == (ssize_t)sizeof(venc_config)) { + venc_config c; + memcpy(&c, buf, sizeof c); + bool ok = configure(c, fds, nfds); + for (int i = 0; i < nfds; i++) close(fds[i]); + reply(ok ? 0 : -1, 0, false); + } else if (type == VENC_FRAME && n == (ssize_t)sizeof(venc_frame)) { + venc_frame f; + memcpy(&f, buf, sizeof f); + uint32_t bytes = 0; + bool key = false; + bool ok = encode(f, &bytes, &key); + reply(ok ? 0 : -1, bytes, key); + } else if (type == VENC_TOUCH && n == (ssize_t)sizeof(venc_touch)) { + venc_touch t; + memcpy(&t, buf, sizeof t); + touch(t); + for (int i = 0; i < nfds; i++) close(fds[i]); + } else if (type == VENC_BITRATE && n == (ssize_t)sizeof(venc_bitrate)) { + venc_bitrate b; + memcpy(&b, buf, sizeof b); + set_bitrate(b.bitrate); + for (int i = 0; i < nfds; i++) close(fds[i]); + } else { + LOG("unexpected message %u of %zd bytes; closing", type, n); + for (int i = 0; i < nfds; i++) close(fds[i]); + return; + } + } + } + +private: + ssize_t receive(uint8_t *buf, size_t len, int *fds, int *nfds) { + char control[CMSG_SPACE(sizeof(int) * VENC_MAX_BUFFERS * 2)]; + iovec iov = {buf, len}; + msghdr m = {}; + m.msg_iov = &iov; + m.msg_iovlen = 1; + m.msg_control = control; + m.msg_controllen = sizeof control; + ssize_t n = recvmsg(fd_, &m, MSG_CMSG_CLOEXEC); + for (cmsghdr *c = CMSG_FIRSTHDR(&m); n > 0 && c; c = CMSG_NXTHDR(&m, c)) { + if (c->cmsg_level != SOL_SOCKET || c->cmsg_type != SCM_RIGHTS) continue; + int count = (int)((c->cmsg_len - CMSG_LEN(0)) / sizeof(int)); + memcpy(fds, CMSG_DATA(c), sizeof(int) * std::min(count, VENC_MAX_BUFFERS * 2)); + *nfds = std::min(count, VENC_MAX_BUFFERS * 2); + } + return n; + } + + void reply(int32_t status, uint32_t bytes, bool key) { + venc_done d = {VENC_DONE, status, bytes, key ? 1u : 0u}; + send(fd_, &d, sizeof d, MSG_NOSIGNAL); + } + + void release() { + if (codec_) { + AMediaCodec_stop(codec_); + AMediaCodec_delete(codec_); + codec_ = nullptr; + } + for (auto &m : inputs_) munmap(m.data, m.size); + for (auto &m : outputs_) munmap(m.data, m.size); + inputs_.clear(); + outputs_.clear(); + header_.clear(); + } + + AMediaCodec *create(const venc_config &c, bool with_profile) { + const char *mime = c.codec == VENC_HEVC ? "video/hevc" : "video/avc"; + AMediaCodec *codec = AMediaCodec_createEncoderByType(mime); + if (!codec) return nullptr; + float fps = c.fps_num ? (float)c.fps_den / (float)c.fps_num : 60.0f; + AMediaFormat *f = AMediaFormat_new(); + AMediaFormat_setString(f, AMEDIAFORMAT_KEY_MIME, mime); + AMediaFormat_setInt32(f, AMEDIAFORMAT_KEY_WIDTH, (int32_t)c.width); + AMediaFormat_setInt32(f, AMEDIAFORMAT_KEY_HEIGHT, (int32_t)c.height); + AMediaFormat_setInt32(f, AMEDIAFORMAT_KEY_COLOR_FORMAT, kColorFormatYuv420SemiPlanar); + AMediaFormat_setInt32(f, AMEDIAFORMAT_KEY_BIT_RATE, (int32_t)std::max(c.bitrate, 500000u)); + AMediaFormat_setInt32(f, "bitrate-mode", c.vbr ? 1 : 2); + AMediaFormat_setFloat(f, AMEDIAFORMAT_KEY_FRAME_RATE, fps); + AMediaFormat_setFloat(f, "operating-rate", fps); + AMediaFormat_setInt32(f, "priority", 0); + AMediaFormat_setInt32(f, "latency", 1); + AMediaFormat_setInt32(f, "max-bframes", 0); + AMediaFormat_setInt32(f, "prepend-sps-pps-to-idr-frames", 1); + float gop_seconds = c.gop && c.gop < 0xffff ? (float)c.gop / fps : 3600.0f; + AMediaFormat_setFloat(f, AMEDIAFORMAT_KEY_I_FRAME_INTERVAL, std::max(gop_seconds, 0.1f)); + if (with_profile) { + int32_t profile = c.codec == VENC_HEVC ? (c.profile == 2 ? 2 : 1) : avc_profile(c.profile); + if (profile) AMediaFormat_setInt32(f, "profile", profile); + } + media_status_t s = AMediaCodec_configure(codec, f, nullptr, nullptr, AMEDIACODEC_CONFIGURE_FLAG_ENCODE); + AMediaFormat_delete(f); + if (s == AMEDIA_OK) s = AMediaCodec_start(codec); + if (s != AMEDIA_OK) { + AMediaCodec_delete(codec); + return nullptr; + } + return codec; + } + + bool configure(const venc_config &c, const int *fds, int nfds) { + release(); + if (c.inputs + c.outputs != (uint32_t)nfds || c.width < 64 || c.height < 64 || c.stride < c.width || + c.rows < c.height || (uint64_t)c.stride * c.rows * 3 / 2 > c.input_size) { + LOG("bad config: %u+%u buffers for %d fds, %ux%u stride %u", c.inputs, c.outputs, nfds, c.width, c.height, + c.stride); + return false; + } + for (int i = 0; i < nfds; i++) { + bool input = (uint32_t)i < c.inputs; + size_t size = input ? c.input_size : c.output_size; + void *p = mmap(nullptr, size, input ? PROT_READ : PROT_READ | PROT_WRITE, MAP_SHARED, fds[i], 0); + if (p == MAP_FAILED) { + LOG("could not map buffer %d: %s", i, strerror(errno)); + release(); + return false; + } + (input ? inputs_ : outputs_).push_back({(uint8_t *)p, size}); + } + codec_ = create(c, true); + if (!codec_) codec_ = create(c, false); + if (!codec_) { + LOG("no %s encoder for %ux%u", c.codec == VENC_HEVC ? "HEVC" : "H.264", c.width, c.height); + release(); + return false; + } + config_ = c; + dst_stride_ = (int32_t)c.width; + dst_rows_ = (int32_t)c.height; + using InputFormat = AMediaFormat *(*)(AMediaCodec *); + static auto input_format = (InputFormat)dlsym(RTLD_DEFAULT, "AMediaCodec_getInputFormat"); + if (AMediaFormat *in = input_format ? input_format(codec_) : nullptr) { + int32_t v; + if (AMediaFormat_getInt32(in, "stride", &v) && v >= (int32_t)c.width) dst_stride_ = v; + if (AMediaFormat_getInt32(in, "slice-height", &v) && v >= (int32_t)c.height) dst_rows_ = v; + AMediaFormat_delete(in); + } + LOG("%s %ux%u at %.2f fps, %u kbit/s %s, input stride %d rows %d", c.codec == VENC_HEVC ? "HEVC" : "H.264", + c.width, c.height, c.fps_num ? (double)c.fps_den / c.fps_num : 0.0, c.bitrate / 1000, + c.vbr ? "VBR" : "CBR", dst_stride_, dst_rows_); + return true; + } + + static void touch(const venc_touch &t) { + using SendTouch = void (*)(int, int, int, int); + static SendTouch send_touch = [] { + void *wayland = dlopen("libdroiddeckwayland.so", RTLD_NOW | RTLD_NOLOAD); + auto fn = wayland ? (SendTouch)dlsym(wayland, "droiddeck_wayland_send_touch") : nullptr; + if (!fn) LOG("remote touch unavailable: %s", dlerror()); + return fn; + }(); + if (!send_touch || t.action > VENC_TOUCH_UP) return; + int x = (int)((uint64_t)std::min(t.x, 65535u) * (kTouchWidth - 1) / 65535); + int y = (int)((uint64_t)std::min(t.y, 65535u) * (kTouchHeight - 1) / 65535); + send_touch((int)t.action, kRemoteTouchId, x, y); + } + + void set_bitrate(uint32_t bitrate) { + if (!codec_) return; + AMediaFormat *p = AMediaFormat_new(); + AMediaFormat_setInt32(p, "video-bitrate", (int32_t)std::max(bitrate, 500000u)); + AMediaCodec_setParameters(codec_, p); + AMediaFormat_delete(p); + } + + bool encode(const venc_frame &f, uint32_t *bytes, bool *key) { + if (!codec_ || f.input >= inputs_.size() || f.output >= outputs_.size()) return false; + if (f.keyframe) { + AMediaFormat *p = AMediaFormat_new(); + AMediaFormat_setInt32(p, "request-sync", 0); + AMediaCodec_setParameters(codec_, p); + AMediaFormat_delete(p); + } + ssize_t in = AMediaCodec_dequeueInputBuffer(codec_, 100000); + if (in < 0) return false; + size_t capacity = 0; + uint8_t *dst = AMediaCodec_getInputBuffer(codec_, (size_t)in, &capacity); + size_t need = (size_t)dst_stride_ * dst_rows_ + (size_t)dst_stride_ * ((config_.height + 1) / 2); + if (!dst || capacity < need) return false; + const uint8_t *src = inputs_[f.input].data; + for (uint32_t y = 0; y < config_.height; y++) + memcpy(dst + (size_t)y * dst_stride_, src + (size_t)y * config_.stride, config_.width); + const uint8_t *src_uv = src + (size_t)config_.stride * config_.rows; + uint8_t *dst_uv = dst + (size_t)dst_stride_ * dst_rows_; + for (uint32_t y = 0; y < (config_.height + 1) / 2; y++) + memcpy(dst_uv + (size_t)y * dst_stride_, src_uv + (size_t)y * config_.stride, config_.width); + if (AMediaCodec_queueInputBuffer(codec_, (size_t)in, 0, need, (uint64_t)std::max(f.pts_us, 0), 0) != + AMEDIA_OK) + return false; + Mapping &out = outputs_[f.output]; + for (int tries = 0; tries < 20; tries++) { + AMediaCodecBufferInfo info; + ssize_t o = AMediaCodec_dequeueOutputBuffer(codec_, &info, 20000); + if (o == AMEDIACODEC_INFO_TRY_AGAIN_LATER || o == AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED || + o == AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED) + continue; + if (o < 0) return false; + size_t size = 0; + uint8_t *data = AMediaCodec_getOutputBuffer(codec_, (size_t)o, &size); + const uint8_t *payload = data ? data + info.offset : nullptr; + size_t length = data ? (size_t)info.size : 0; + if (info.flags & kBufferFlagCodecConfig) { + header_.assign(payload, payload + length); + AMediaCodec_releaseOutputBuffer(codec_, (size_t)o, false); + continue; + } + *key = (info.flags & kBufferFlagKeyFrame) != 0; + bool prepend = *key && !header_.empty() && + (length < header_.size() || memcmp(payload, header_.data(), header_.size()) != 0); + size_t total = length + (prepend ? header_.size() : 0); + bool fits = payload && total <= out.size; + if (fits) { + if (prepend) memcpy(out.data, header_.data(), header_.size()); + memcpy(out.data + (prepend ? header_.size() : 0), payload, length); + *bytes = (uint32_t)total; + } + AMediaCodec_releaseOutputBuffer(codec_, (size_t)o, false); + return fits; + } + return false; + } + + int fd_; + AMediaCodec *codec_ = nullptr; + venc_config config_ = {}; + int32_t dst_stride_ = 0, dst_rows_ = 0; + std::vector inputs_, outputs_; + std::vector header_; +}; + +std::atomic g_listener{-1}; + +void serve(int listener) { + for (;;) { + int fd = accept4(listener, nullptr, nullptr, SOCK_CLOEXEC); + if (fd < 0) { + if (errno == EINTR) continue; + return; + } + std::thread([fd] { + Session s(fd); + s.run(); + }).detach(); + } +} + +} // namespace + +extern "C" JNIEXPORT jboolean JNICALL +Java_com_droiddeck_launcher_session_VideoEncodeBridge_nativeStart(JNIEnv *env, jobject, jstring jpath) { + if (g_listener.load() >= 0) return JNI_TRUE; + const char *path = env->GetStringUTFChars(jpath, nullptr); + sockaddr_un addr = {}; + addr.sun_family = AF_UNIX; + bool fits = strlen(path) < sizeof addr.sun_path; + if (fits) strcpy(addr.sun_path, path); + int fd = fits ? socket(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC, 0) : -1; + if (fd >= 0) { + unlink(path); + if (bind(fd, (sockaddr *)&addr, sizeof addr) != 0 || listen(fd, 4) != 0) { + LOG("could not listen on %s: %s", path, strerror(errno)); + close(fd); + fd = -1; + } + } + env->ReleaseStringUTFChars(jpath, path); + if (fd < 0) return JNI_FALSE; + g_listener.store(fd); + std::thread(serve, fd).detach(); + return JNI_TRUE; +} + +extern "C" JNIEXPORT void JNICALL +Java_com_droiddeck_launcher_session_VideoEncodeBridge_nativeStop(JNIEnv *, jobject) { + int fd = g_listener.exchange(-1); + if (fd >= 0) { + shutdown(fd, SHUT_RDWR); + close(fd); + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/DeckyMenu.kt b/app/src/main/java/com/droiddeck/launcher/DeckyMenu.kt index 9f8a27f9f7..240202daec 100644 --- a/app/src/main/java/com/droiddeck/launcher/DeckyMenu.kt +++ b/app/src/main/java/com/droiddeck/launcher/DeckyMenu.kt @@ -11,29 +11,46 @@ import java.io.File internal class DeckyMenu(private val activity: android.app.Activity, private val ui: android.os.Handler) { var deckyInstalled by mutableStateOf(null) - var deckyReleases by mutableStateOf>(emptyList()) + var deckyLatest by mutableStateOf(null) + var deckyBranch by mutableIntStateOf(DeckyManager.BRANCH_STABLE) + private var deckyChannels = DeckyManager.ReleaseChannels(emptyList(), emptyList()) var deckyChecking by mutableStateOf(false) var deckyStage by mutableStateOf(null) var deckyPercent by mutableIntStateOf(-1) var deckyDownloadingBinary by mutableStateOf(false) var deckySupervisor by mutableStateOf(false) + var deckyPendingZip by mutableStateOf(null) var deckyReleaseRequest = 0 fun refreshDecky() { val request = ++deckyReleaseRequest + deckyBranch = DeckyManager.branch(activity) deckyChecking = true Thread({ val channels = runCatching { DeckyManager.releaseChannels(activity) } .getOrElse { DeckyManager.ReleaseChannels(emptyList(), emptyList()) } ui.post { if (request == deckyReleaseRequest) { - deckyReleases = channels.stable.ifEmpty { channels.prerelease } + deckyChannels = channels + deckyLatest = DeckyManager.latest(channels, deckyBranch) deckyChecking = false } } }, "decky-releases").start() } + fun switchDeckyBranch(branch: Int) { + if (branch == deckyBranch || deckyStage != null || SessionState.running) return + val saved = runCatching { DeckyManager.setBranch(activity, branch) } + if (saved.isFailure) { + android.widget.Toast.makeText(activity, R.string.decky_channel_failed, android.widget.Toast.LENGTH_LONG).show() + return + } + deckyBranch = branch + deckyLatest = DeckyManager.latest(deckyChannels, branch) + refreshDecky() + } + fun installDecky(release: DeckyManager.Release) { if (deckyStage != null || SessionState.running) return deckyStage = activity.getString(R.string.store_starting); deckyPercent = -1 @@ -49,6 +66,17 @@ internal class DeckyMenu(private val activity: android.app.Activity, private val } fun importPluginZip(archive: File) { + if (deckyStage != null || SessionState.running || deckyInstalled == null) return + deckyPendingZip = archive + } + + fun cancelPluginZip() { + deckyPendingZip = null + } + + fun confirmPluginZip() { + val archive = deckyPendingZip ?: return + deckyPendingZip = null if (deckyStage != null || SessionState.running || deckyInstalled == null) return deckyStage = activity.getString(R.string.decky_plugin_starting); deckyPercent = -1 Thread({ diff --git a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt index 66b43bc347..4e455d3c1d 100644 --- a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt @@ -119,6 +119,7 @@ class MainActivity : ComponentActivity() { private var showNonAdreno by mutableStateOf(null) private var glThread by mutableStateOf(true) private var noGlError by mutableStateOf(true) + private var returnAfterGame by mutableStateOf(true) private var steamRepairQueued by mutableStateOf(false) private var mangoapp by mutableStateOf(true) private var steamController by mutableStateOf(SessionPrefs.CONTROLLER_DECK) @@ -160,7 +161,7 @@ class MainActivity : ComponentActivity() { private var directAudio by mutableStateOf(false) private var picturePosition by mutableStateOf("center") private var stretch16x9 by mutableStateOf(false) - private var orientation by mutableStateOf(android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE) + private var orientation by mutableStateOf(android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) private var launcherFullscreen by mutableStateOf(true) private var downloadSource by mutableStateOf(DownloadSource.MODE_AUTO) private var downloadMirror by mutableStateOf("") @@ -768,6 +769,9 @@ class MainActivity : ComponentActivity() { setContent { DroidDeckTheme(theme, appScale = appScale) { com.droiddeck.launcher.ui.FocusGlideHost(androidx.compose.ui.Modifier.fillMaxSize().exposeTestTags()) { + if (decky.deckyPendingZip != null) com.droiddeck.launcher.ui.DeckyZipWarningDialog( + onConfirm = { decky.confirmPluginZip() }, onCancel = { decky.cancelPluginZip() }, + ) val page: (@Composable () -> Unit)? = when { showPerformance -> { { PerformanceHost() } } showComponents -> { { ComponentsHost() } } @@ -1631,6 +1635,7 @@ class MainActivity : ComponentActivity() { forceSsbs = forceSsbs, syncBackend = if (mode == SessionService.MODE_STEAM) SessionPrefs.syncBackendOf(fastSync, fsyncFirst, syncFallback) else null, steamClientArch = if (mode == SessionService.MODE_STEAM) steamClientArch else null, + returnAfterGame = if (mode == SessionService.MODE_STEAM) returnAfterGame else null, steamRepairQueued = steamRepairQueued, mangoapp = mangoapp, steamController = if (mode == SessionService.MODE_STEAM) steamController else null, @@ -1646,7 +1651,8 @@ class MainActivity : ComponentActivity() { wifiDiscoveryAsked = wifiDiscoveryAsked, wifiDiscoveryBlocked = wifiDiscoveryBlocked, deckyInstalled = if (mode == SessionService.MODE_STEAM) decky.deckyInstalled else null, - deckyLatestRelease = if (mode == SessionService.MODE_STEAM) decky.deckyReleases.firstOrNull() else null, + deckyLatestRelease = if (mode == SessionService.MODE_STEAM) decky.deckyLatest else null, + deckyBranch = decky.deckyBranch, deckyChecking = decky.deckyChecking, deckyStage = decky.deckyStage, deckyPercent = decky.deckyPercent, deckyDownloadingBinary = decky.deckyDownloadingBinary, deckyEnabled = decky.deckySupervisor, deckySessionRunning = SessionState.running, @@ -1716,6 +1722,7 @@ class MainActivity : ComponentActivity() { onSteamRepair = { steamRepairQueued = SteamRepair.queue(this) }, onSteamClientArch = { id -> SessionPrefs.setSteamClientArch(this, id); steamClientArch = id; refresh() }, onMangoapp = { on -> SessionPrefs.setMangoapp(this, on); mangoapp = on }, + onReturnAfterGame = { on -> SessionPrefs.setReturnAfterGame(this, on); returnAfterGame = on }, onSteamController = { id -> SessionPrefs.setSteamController(this, id); steamController = id }, onRunSteamAtStartup = { on -> SessionPrefs.setRunSteamAtStartup(this, on) @@ -1729,6 +1736,7 @@ class MainActivity : ComponentActivity() { onBootMovieChanged = { loadBootMovie() }, onDeckyInstall = { release -> decky.installDecky(release) }, onDeckyCheck = { decky.refreshDecky() }, + onDeckyBranch = { branch -> decky.switchDeckyBranch(branch) }, onDeckyEnabled = { enabled -> DeckyManager.setSupervisorEnabled(this, enabled); decky.deckySupervisor = enabled }, onDeckyUninstall = { DeckyManager.uninstall(this, wipeData = false) @@ -1881,6 +1889,7 @@ class MainActivity : ComponentActivity() { steamClientArch = SessionPrefs.steamClientArch(this) steamRepairQueued = SteamRepair.queued(this) mangoapp = SessionPrefs.mangoapp(this) + returnAfterGame = SessionPrefs.returnAfterGame(this) steamController = SessionPrefs.steamController(this) runSteamAtStartup = SessionPrefs.runSteamAtStartup(this) loadBootMovie() diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index eab2ea02bc..e7c3385d30 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -29,6 +29,7 @@ import androidx.activity.ComponentActivity import androidx.activity.OnBackPressedCallback import androidx.activity.result.contract.ActivityResultContracts import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableIntStateOf import androidx.compose.runtime.mutableStateOf @@ -111,7 +112,7 @@ import com.droiddeck.launcher.ui.HudText import com.droiddeck.launcher.ui.LoadingOverlay import com.droiddeck.launcher.ui.SessionDrawer import com.droiddeck.launcher.ui.SessionPausedOverlay -import com.droiddeck.launcher.ui.SecondScreenWindow +import com.droiddeck.launcher.ui.SecondScreenPresentation import com.droiddeck.launcher.ui.DroidDeckTheme import com.droiddeck.launcher.wayland.CompositorHost import com.droiddeck.launcher.wayland.WaylandCompositor @@ -306,6 +307,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private var achievementsInFront by mutableStateOf(null) private var achievementsOpen by mutableStateOf(false) private var hudOn by mutableStateOf(true) + private var hudFps by mutableStateOf(true) + private var hudBattery by mutableStateOf(true) + private var hudGraph by mutableStateOf(true) + private var hudColor by mutableStateOf(SessionPrefs.HUD_COLOR_MINT) + private var hudOpacity by mutableStateOf(SessionPrefs.HUD_OPACITY_DEFAULT) private var upscaler by mutableStateOf(0) private var upscaleSharpness by mutableStateOf(75) private var effects by mutableStateOf(ScreenEffects.OFF) @@ -361,7 +367,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private var selectedSecondScreenDisplay by mutableStateOf(SessionState.secondScreenDisplay) private var started = false private lateinit var displayManager: DisplayManager - private var secondScreenPresentation: SecondScreenWindow? = null + private var secondScreenPresentation: SecondScreenPresentation? = null private val displayListener = object : DisplayManager.DisplayListener { override fun onDisplayAdded(displayId: Int) = refreshSecondScreenDisplays() override fun onDisplayRemoved(displayId: Int) = refreshSecondScreenDisplays() @@ -469,6 +475,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { val bridge = PadBridge(File(LinuxRuntime.sessionRoot(this), "dev/input")) bridge.setSelectSteam(ControllerPrefs.read(this).selectSteam) + bridge.setBuiltinPad(SessionState.mode != SessionService.MODE_STEAM || SessionPrefs.builtinPad(this)) padBridge = bridge SessionState.padBridge = bridge if (Build.VERSION.SDK_INT >= 31) { @@ -638,8 +645,9 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { com.droiddeck.launcher.ui.FocusGlideHost(androidx.compose.ui.Modifier.fillMaxSize()) { 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 (hud.text.isNotEmpty() || hud.graph.size >= 2) HudText(hud.text, hud.graph, hudColor, hudOpacity) + val phonePanel = glassesOutputActive && !loading.visible && !drawerOpen && !pcKeyboardOpen + if (phonePanel) GlassesPhonePanel(glasses, steamVrStatus == SteamVr.Status.RUNNING, headTracking) if (trackingRecovery != null && !drawerOpen && !pcKeyboardOpen && !loading.visible) { androidx.compose.ui.viewinterop.AndroidView( factory = { com.droiddeck.launcher.ui.TrackingRecoveryView(it) }, @@ -647,14 +655,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { update = { it.update(trackingRecovery, !glassesOutputActive && glasses.usable && glasses.sbs) }, ) } - if (GlassesRendering.usesGlasses(glasses, glassesOutputActive, steamVrStatus == SteamVr.Status.RUNNING) && + if (!phonePanel && 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, + if (!phonePanel && 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 @@ -752,6 +760,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { isHomeApp = isHomeApp, androidApps = androidApps, hudOn = hudOn, + hudFps = hudFps, + hudBattery = hudBattery, + hudGraph = hudGraph, + hudColor = hudColor, + hudOpacity = hudOpacity, upscaler = upscaler, upscaleSharpness = upscaleSharpness, effects = effects, cardboard = cardboard, @@ -779,6 +792,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { secondScreenDisplays = secondScreenDisplays, selectedSecondScreenDisplay = selectedSecondScreenDisplay, onHud = { on -> SessionPrefs.setHudEnabled(this@SessionActivity, on); hudOn = on; hud.refresh() }, + onHudFps = { on -> SessionPrefs.setHudShowFps(this@SessionActivity, on); hudFps = on; hud.refresh() }, + onHudBattery = { on -> SessionPrefs.setHudShowBattery(this@SessionActivity, on); hudBattery = on; hud.refresh() }, + onHudGraph = { on -> SessionPrefs.setHudShowGraph(this@SessionActivity, on); hudGraph = on; hud.refresh() }, + onHudColor = { color -> SessionPrefs.setHudColor(this@SessionActivity, color); hudColor = color }, + onHudOpacity = { percent -> SessionPrefs.setHudOpacity(this@SessionActivity, percent); hudOpacity = percent }, onUpscaler = { m -> SessionPrefs.setUpscaler(this@SessionActivity, m); upscaler = m WaylandCompositor.nativeSetUpscaler(m) @@ -998,6 +1016,54 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { }, 90) } + @androidx.compose.runtime.Composable + private fun GlassesPhonePanel(glasses: com.droiddeck.launcher.glasses.GlassesState, vr: Boolean, headTracking: Boolean) { + val battery by androidx.compose.runtime.produceState(null) { + while (true) { + val b = registerReceiver(null, android.content.IntentFilter(android.content.Intent.ACTION_BATTERY_CHANGED)) + val level = b?.getIntExtra(android.os.BatteryManager.EXTRA_LEVEL, -1) ?: -1 + val scale = b?.getIntExtra(android.os.BatteryManager.EXTRA_SCALE, 100) ?: 100 + val tenths = b?.getIntExtra(android.os.BatteryManager.EXTRA_TEMPERATURE, -1) ?: -1 + value = if (level < 0) null else getString(R.string.glasses_phone_battery, level * 100 / scale.coerceAtLeast(1), tenths / 10) + kotlinx.coroutines.delay(30_000) + } + } + val pads = com.droiddeck.launcher.input.VrControllers.settings.collectAsState().value + com.droiddeck.launcher.ui.GlassesPhonePanel(glasses.model, battery, com.droiddeck.launcher.ui.GlassesPhoneActions( + onRecenter = if (headTracking) ({ headTracker?.recenter() }) else null, + onRecenterJoyCons = if (vr && glasses.usesSpatialControllers(glassesSettings) && glassesSettings.joyConTracking) + joyConVr?.let { { it.recenter() } } else null, + onSteamVrMenu = if (vr && SessionState.mode == SessionService.MODE_STEAM) ({ sendSteamGuide() }) else null, + onSwitchSticks = if (vr && pads.emulate != com.droiddeck.launcher.input.VrControllers.Emulate.OFF) ({ switchVrSticks() }) else null, + controllers = getString(when (pads.emulate) { + com.droiddeck.launcher.input.VrControllers.Emulate.OFF -> R.string.vr_controllers_off + com.droiddeck.launcher.input.VrControllers.Emulate.INDEX -> R.string.vr_controllers_index + com.droiddeck.launcher.input.VrControllers.Emulate.TOUCH -> R.string.vr_controllers_touch + com.droiddeck.launcher.input.VrControllers.Emulate.VIVE -> R.string.vr_controllers_vive + }), + onNextControllers = if (vr) ({ + val all = com.droiddeck.launcher.input.VrControllers.Emulate.entries + com.droiddeck.launcher.input.VrControllers.setEmulate(this, all[(pads.emulate.ordinal + 1) % all.size]) + }) else null, + onKeyboard = { keyboard?.toggle() }, + onSessionMenu = { drawerOpen = true }, + onStopSteamVr = if (vr) ({ steamVrAction("stop") }) else null, + brightness = glasses.brightness, + brightnessMax = glasses.brightnessMax, + onBrightness = if (glasses.canControl && glasses.hardwareControls) Glasses::setBrightness else null, + )) + } + + /** The SteamVR driver switches pad sticks between hands and game on both stick clicks together. */ + private fun switchVrSticks() { + val chord = { down: Boolean -> padBridge?.applyTouch { state -> + state.press(com.droiddeck.launcher.input.PadState.L3, down) + state.press(com.droiddeck.launcher.input.PadState.R3, down) + } } + chord(true) + uiHandler.postDelayed({ chord(false) }, 120) + } + private fun triggerSteamQam() { drawerOpen = false padBridge?.triggerQam() @@ -1343,6 +1409,11 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { unfoldedControls = SessionPrefs.unfoldedControls(this) picturePosition = SessionPrefs.picturePosition(this) hudOn = SessionPrefs.hudEnabled(this) + hudFps = SessionPrefs.hudShowFps(this) + hudBattery = SessionPrefs.hudShowBattery(this) + hudGraph = SessionPrefs.hudShowGraph(this) + hudColor = SessionPrefs.hudColor(this) + hudOpacity = SessionPrefs.hudOpacity(this) upscaler = SessionPrefs.upscaler(this) upscaleSharpness = SessionPrefs.upscaleSharpness(this) effects = SessionPrefs.screenEffects(this) @@ -1525,10 +1596,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } val runtimeDir = File(filesDir, ".wayland-rt").apply { mkdirs() } FileUtils.copyAsset(this, "wayland/keymap.xkb", File(runtimeDir, "keymap.xkb")) + com.droiddeck.launcher.input.VrControllers.publish(this) val turnip = TurnipDriver(this) com.droiddeck.launcher.gpu.DriverSetupLog.write(this, "surface.driver-setup") - if (!CompositorHost.isStarted) CompositorHost.displayChoice = SessionPrefs.androidDriver(this) + if (!CompositorHost.isStarted) { + CompositorHost.displayChoice = SessionPrefs.androidDriver(this) + com.droiddeck.launcher.gpu.AutoDriverTrial.displayStarting(this, SessionPrefs.androidDriver(this)) + } val driverId = if (CompositorHost.isStarted) null else turnip.install() val previous = SessionState.outputSize @@ -2336,7 +2411,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { var presentation = secondScreenPresentation if (presentation?.display?.displayId != target.displayId) { presentation?.closeControls() - presentation = SecondScreenWindow( + presentation = SecondScreenPresentation( this, target, sendPointer = ::moveSecondScreenPointer, sendButton = { button, pressed -> @@ -2676,7 +2751,8 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { ?.let { FileUtils.readString(it)?.trim()?.lowercase() } ?: SessionPrefs.oscMode(this) val controls = onScreenControls ?: return - if (pipUi || unfoldedPanel != null || pcKeyboardOpen) { + if (pipUi || unfoldedPanel != null || pcKeyboardOpen || + (SessionState.mode == SessionService.MODE_STEAM && !SessionPrefs.builtinPad(this))) { onScreenButtonsVisible = false controls.releaseAll() controls.visibility = View.GONE diff --git a/app/src/main/java/com/droiddeck/launcher/core/AddonPack.kt b/app/src/main/java/com/droiddeck/launcher/core/AddonPack.kt index db4c06939e..d54a5fff5d 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/AddonPack.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/AddonPack.kt @@ -19,7 +19,10 @@ import java.io.FileInputStream * yet to its pr-N release on DroidDeck-CI. The APK pins the pack's SHA-256, so only the bytes this build * was made with install, whichever host serves them. */ -internal class AddonPack(val name: String, private val sha256: String, val size: Long, private val required: List) { +internal class AddonPack( + val name: String, private val sha256: String, val size: Long, private val required: List, + private val reuseDeviceCopy: Boolean = sha256.isEmpty() && !BuildConfig.CI_BUILD, +) { sealed interface State { data object Missing : State data class Downloading(val progress: Float) : State @@ -40,10 +43,20 @@ internal class AddonPack(val name: String, private val sha256: String, val size: private fun root(context: Context) = File(context.filesDir, "addons/$name") /** App-private and written only after the archive matched the pinned digest. */ - fun dir(context: Context) = File(root(context), sha256) + fun dir(context: Context) = File(root(context), version(context)) fun file(context: Context, relative: String) = File(dir(context), relative) - fun installed(context: Context): Boolean = available && File(dir(context), COMPLETE).isFile + fun installed(context: Context): Boolean = version(context).isNotEmpty() && File(dir(context), COMPLETE).isFile + + // A build made outside CI pins no packs, so it runs the newest one a CI build already verified and installed. + private fun version(context: Context): String = if (!reuseDeviceCopy) sha256 else deviceCopy(context).orEmpty() + + private fun deviceCopy(context: Context): String? = root(context).listFiles().orEmpty() + .filter { dir -> + dir.isDirectory && runCatching { File(dir, COMPLETE).readText().trim() }.getOrNull() == dir.name && + required.all { File(dir, it).isFile } + } + .maxByOrNull { it.lastModified() }?.name fun refresh(context: Context): State { val now = mutableState.value @@ -86,7 +99,7 @@ internal class AddonPack(val name: String, private val sha256: String, val size: private fun install(context: Context): Boolean { if (!available) { - Log.w(TAG, "$name: this build has no pack") + Log.w(TAG, if (reuseDeviceCopy) "$name: this build has no pack and none is installed" else "$name: this build has no pack") return false } val root = root(context).apply { mkdirs() } 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 2dfa6ea3f3..903851a5a9 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/DeviceReport.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/DeviceReport.kt @@ -252,6 +252,7 @@ object DeviceReport { k("Guest host name", SessionPrefs.guestHostname(context)) k("DirectAudio for games", SessionPrefs.directAudio(context)) k("Stretch 16:9 to panel", SessionPrefs.stretch16x9(context)) + k("Return to launcher after a game", SessionPrefs.returnAfterGame(context)) k("Microphone", SessionPrefs.micEnabled(context)) k("On-screen controls", SessionPrefs.oscMode(context)) k("Touch mode", SessionPrefs.touchMode(context)) 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 2527c57e82..183076188d 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/Downloader.java +++ b/app/src/main/java/com/droiddeck/launcher/core/Downloader.java @@ -54,7 +54,12 @@ public final class Downloader { 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); + return downloadCandidates(url, sources(url, expectedSha256), destination, resume, expectedSha256, progress); + } + + /** A third-party mirror may only serve bytes that can be checked against a digest from a direct source. */ + static List sources(String url, String expectedSha256) { + return expectedSha256 == null ? java.util.Collections.singletonList(url) : DownloadSource.INSTANCE.candidates(url); } // Package-private for the local multi-source HTTP test. 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 a667543a69..491101dba2 100644 --- a/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt +++ b/app/src/main/java/com/droiddeck/launcher/core/LogRedactor.kt @@ -2,14 +2,51 @@ package com.droiddeck.launcher.core object LogRedactor { private val EMAIL = Regex("[A-Za-z0-9._%+\\-]+@[A-Za-z0-9.\\-]+\\.[A-Za-z]{2,}") + private val HIDL_SHARED_LIBRARY = Regex( + "(?:android\\.(?:hardware|frameworks|hidl|system)|vendor\\.[A-Za-z0-9_]+\\.hardware)" + + "(?:\\.[A-Za-z0-9_]+)+@[0-9]+\\.[0-9]+(?:-[A-Za-z0-9_]+)*\\.so" + ) + private val hidlMatcher = object : ThreadLocal() { + override fun initialValue(): java.util.regex.Matcher = HIDL_SHARED_LIBRARY.toPattern().matcher("") + } + + private fun isHidlLoaderDiagnostic(input: String, match: MatchResult): Boolean { + val matcher = hidlMatcher.get()!! + val isLibrary = try { matcher.reset(match.value).matches() } finally { matcher.reset("") } + if (!isLibrary) return false + val start = match.range.first + val end = match.range.last + 1 + val prefix = "library \"" + val suffix = "\" not found" + val earliestQuote = (start - 4096).coerceAtLeast(0) + var quote = start - 1 + while (quote >= earliestQuote && input[quote] != '"') { + val char = input[quote] + if (!char.isLetterOrDigit() && char !in "/._-") return false + quote-- + } + if (quote < earliestQuote) return false + val pathStart = quote + 1 + if (pathStart < start && (input[start - 1] != '/' || + !(input.regionMatches(pathStart, "/vendor/", 0, 8) || + input.regionMatches(pathStart, "/system/", 0, 8)))) return false + val prefixStart = quote - prefix.length + 1 + val suffixEnd = end + suffix.length + return prefixStart >= 0 && suffixEnd <= input.length && + input.regionMatches(prefixStart, prefix, 0, prefix.length, ignoreCase = true) && + input.regionMatches(end, suffix, 0, suffix.length, ignoreCase = true) && + (prefixStart == 0 || !(input[prefixStart - 1].isLetterOrDigit() || input[prefixStart - 1] == '_')) && + (suffixEnd == input.length || !(input[suffixEnd].isLetterOrDigit() || input[suffixEnd] == '_')) + } + private val JWT_LABELLED = Regex("(?i)(\\bJWT[\\s=:]+)(\\d{8,})") private val JWT_BASE64 = Regex("ey[A-Za-z0-9_\\-]{6,}\\.[A-Za-z0-9_\\-]{6,}\\.[A-Za-z0-9_\\-]{6,}") private val GUID = Regex("\\b[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}\\b") private val SECRET_KV = Regex( - "(?i)\\b(access[_-]?token|refresh[_-]?token|auth[_-]?token|authtoken|token|authcode|" + + "(?i)(\\b(?:access[_-]?token|refresh[_-]?token|auth[_-]?token|authtoken|token|authcode|" + "auth[_-]?ticket|ticket|sessionid|steamloginsecure|webapikey|api[_-]?key|" + - "machine[_-]?auth(?:[_-]?token)?|machineauth|password|passwd|pwd|secret)" + - "(\\s*[=:]\\s*|=)([^\\s\"'<>&;,]{4,})" + "machine[_-]?auth(?:[_-]?token)?|machineauth|password|passwd|pwd|secret)[\"']?\\s*[=:]\\s*)" + + "(?:([\"'])((?:\\\\.|(?!\\2)[^\\\\\\r\\n]){4,})\\2|([^\\s\"'<>&;,]{4,}))" ) private val GUARD_CODE = Regex( "(?i)((?:steam\\s*)?guard\\s*code[\\s:=]*|two[\\s-]?factor[\\s:=]*|2fa[\\s:=]*)([A-Za-z0-9]{5})" @@ -291,7 +328,7 @@ object LogRedactor { if (out.has("jwt")) out.set(JWT_LABELLED.replace(out.text) { "${it.groupValues[1]}" }) if ("ey" in out.text) out.set(JWT_BASE64.replace(out.text, "")) if (out.has("token", "auth", "ticket", "sessionid", "steamloginsecure", "api", "machine", "pass", "pwd", "secret")) { - out.set(SECRET_KV.replace(out.text) { "${it.groupValues[1]}${it.groupValues[2]}" }) + out.set(SECRET_KV.replace(out.text) { "${it.groupValues[1]}${it.groupValues[2]}${it.groupValues[2]}" }) } if (out.has("guard", "factor", "2fa")) out.set(GUARD_CODE.replace(out.text) { "${it.groupValues[1]}" }) if (out.hasRun(32, ::isHex)) out.set(WEBAPI_KEY.replace(out.text, "")) @@ -309,7 +346,9 @@ object LogRedactor { } if (out.has("login")) out.set(LOGIN_KV.replace(out.text) { "${it.groupValues[1]}${it.groupValues[2]}${quoted(it.groupValues[3])}" }) for (r in accounts) if (r.needs == null || out.has(r.needs)) out.set(r.regex.replace(out.text, "")) - if ('@' in out.text) out.set(EMAIL.replace(out.text, "")) + if ('@' in out.text) out.set(EMAIL.replace(out.text) { m -> + m.value.takeIf { isHidlLoaderDiagnostic(out.text, m) } ?: "" + }) if (out.has("jwt", "token", "ticket", "sessionid", "steamloginsecure", "machineauth")) { out.set(RESIDUAL.replace(out.text) { "${it.groupValues[1]}=" }) } 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 b3bdeb9684..62d04d2477 100644 --- a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt +++ b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGameArt.kt @@ -323,8 +323,8 @@ object AddedGameArt { if (dst.isFile) continue val bytes = get("$CDN$id/$remote") ?: steamAssetUrl(id, remote)?.let { get(it) } ?: continue val tmp = File(cache, "$localName.tmp") - tmp.writeBytes(bytes) - if (tmp.renameTo(dst)) { got = true; File(cache, "$localName.src").writeText(STEAM) } + if (runCatching { tmp.writeBytes(bytes) }.isFailure) { tmp.delete(); continue } + if (tmp.renameTo(dst)) { got = true; runCatching { File(cache, "$localName.src").writeText(STEAM) } } } return got } diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/CoverArt.kt b/app/src/main/java/com/droiddeck/launcher/frontend/CoverArt.kt index 5f30796e4c..db982a0f12 100644 --- a/app/src/main/java/com/droiddeck/launcher/frontend/CoverArt.kt +++ b/app/src/main/java/com/droiddeck/launcher/frontend/CoverArt.kt @@ -63,7 +63,8 @@ object CoverArt { missFile(context, rom).delete() found = true } else { - missFile(context, rom).apply { parentFile?.mkdirs(); writeText(url ?: "") } + runCatching { missFile(context, rom).apply { parentFile?.mkdirs(); writeText(url ?: "") } } + .onFailure { Log.w(TAG, "${rom.name}: miss marker not written: $it") } } } return found diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt b/app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt index 89d5fcbde0..947ed5fd27 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt @@ -50,6 +50,7 @@ data class GlassesState( val noSignal: Boolean = false, val sbsSupport: Int = SBS_UNKNOWN, val sbs90: Boolean = false, + val rates2d: List = listOf(60, 90, 120), val experimental: Boolean = false, val supportsScreen3dof: Boolean = false, val supports30Hz: Boolean = false, @@ -613,12 +614,13 @@ object Glasses { switching3d = modeState.pendingStereo, brightnessMax = m?.brightnessMax ?: 8, volumeMax = m?.volumeMax ?: 8, sunblock = if (m === XrealModel) it.sunblock else _settings.value.sunblock ?: it.sunblock, - hardwareControls = device?.vendorId == VitureProtocol.VENDOR_ID || m === XrealModel, + hardwareControls = device?.vendorId == VitureProtocol.VENDOR_ID || m === XrealModel || m is RokidModel, hasSunblock = m?.hasSunblock == true, diagonalFovDeg = m?.diagonalFovDeg ?: 46f, tracking = it.tracking && link != null, noSignal = noSignal, sbs90 = m?.sbs90 == true, + rates2d = m?.rates2d ?: listOf(60, 90, 120), experimental = m === XrealModel, supportsScreen3dof = link?.hasImu == true, supports30Hz = display?.let(::supports30Hz) == true, @@ -634,7 +636,8 @@ object Glasses { scheduleModeCheck() } - internal fun isGlassesVendor(vid: Int) = vid == VitureProtocol.VENDOR_ID || RayNeoModel.isVendor(vid) || vid == XrealModel.VENDOR_ID + internal fun isGlassesVendor(vid: Int) = vid == VitureProtocol.VENDOR_ID || RayNeoModel.isVendor(vid) || + vid == XrealModel.VENDOR_ID || vid == RokidModel.VENDOR_ID internal fun supports30Hz(display: Display): Boolean { val current = display.mode @@ -654,11 +657,13 @@ object Glasses { ?: VitureProtocol.model(device.productId, name) } else if (XrealModel.matches(device.vendorId, device.productId)) XrealModel - else RayNeoModel.model(device.vendorId, device.productId, name) + else RokidModel.model(device.vendorId, device.productId, name) + ?: RayNeoModel.model(device.vendorId, device.productId, name) } internal fun isGlassesDisplayName(name: String) = - name.contains("VITURE", ignoreCase = true) || RayNeoModel.isDisplay(name) || XrealModel.isDisplay(name) + name.contains("VITURE", ignoreCase = true) || RayNeoModel.isDisplay(name) || XrealModel.isDisplay(name) || + RokidModel.isDisplay(name) private fun findDisplay(usbPresent: Boolean): Display? { return selectGlassesDisplay(displays.getDisplays(DisplayManager.DISPLAY_CATEGORY_PRESENTATION).toList(), usbPresent) @@ -723,6 +728,8 @@ object Glasses { } else VitureLink.open(usb, device, linkListener(generation)) } else if (model === XrealModel) { XrealLink.open(app, xrealListener(generation)) + } else if (model is RokidModel) { + RokidLink.open(usb, device, rokidListener(generation)) } else { val baseKey = calibrationKey!! val gtUsb = RayNeoProtocol.isGt(device.vendorId, device.productId) @@ -790,6 +797,33 @@ object Glasses { } } + private fun rokidListener(generation: Long) = object : RokidLink.Listener { + override fun onReady() = post { + if (generation != linkGeneration) return@post + publish { it.copy(connected = true, controlError = null) } + updateImu() + applyMode(force = false) + } + override fun onValue(message: Int, value: Int) = post { + if (generation != linkGeneration) return@post + when (message) { + VitureProtocol.MSG_GET_DISPLAY -> glassesMode = value + VitureProtocol.MSG_BRIGHTNESS -> publish { it.copy(brightness = value) } + } + } + override fun onPose(raw: ByteArray, pose: FloatArray, timeNs: Long) { + if (generation != linkGeneration) return + imuPackets++ + probe?.invoke(raw, pose) + if (simulating.get() == null) deliver(pose, timeNs) + } + override fun onLost() = post { + if (generation != linkGeneration) return@post + closeLink() + refresh() + } + } + private fun sdkListener(generation: Long) = object : VitureSdkLink.Listener { override fun onSpatial(pose: FloatArray, timeNs: Long, valid: Boolean) { if (generation == linkGeneration) SpatialTracking.accept(pose, timeNs, generation, valid) diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesHardware.kt b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesHardware.kt index 0f6c288334..7362ebf44a 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesHardware.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesHardware.kt @@ -8,6 +8,7 @@ interface GlassesModel { val volumeMax: Int val diagonalFovDeg: Float val sbs90: Boolean + val rates2d: List get() = listOf(60, 90, 120) val hasSunblock: Boolean get() = true val resolutions: List get() = emptyList() fun mode(hz: Int, sbs: Boolean, resolution: GlassesResolution?): Int = mode(hz, sbs) diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesRendering.kt b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesRendering.kt index 4cd7f0a6d3..f8d6f4c5f1 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesRendering.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesRendering.kt @@ -12,8 +12,8 @@ internal object GlassesRendering { fun refreshRates(settings: GlassesSettings, state: GlassesState): List = buildList { if (native30HzAvailable(settings, state)) add(30) add(60) - if (!state.sbs || state.sbs90) add(90) - if (!state.sbs) add(120) + if (state.sbs) { if (state.sbs90) add(90) } + else addAll(state.rates2d.filter { it > 60 }) } fun outputHz(settings: GlassesSettings, state: GlassesState): Int { @@ -21,6 +21,7 @@ internal object GlassesRendering { return when { requested == 30 -> if (native30HzAvailable(settings, state)) 30 else 60 state.sbs && !state.sbs90 -> 60 + !state.sbs && requested !in state.rates2d -> state.rates2d.filter { it <= requested }.maxOrNull() ?: 60 else -> requested } } diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/RokidLink.kt b/app/src/main/java/com/droiddeck/launcher/glasses/RokidLink.kt new file mode 100644 index 0000000000..dbf10a6e65 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/RokidLink.kt @@ -0,0 +1,148 @@ +package com.droiddeck.launcher.glasses + +import android.hardware.usb.UsbConstants +import android.hardware.usb.UsbDevice +import android.hardware.usb.UsbDeviceConnection +import android.hardware.usb.UsbEndpoint +import android.hardware.usb.UsbInterface +import android.hardware.usb.UsbManager +import android.os.SystemClock +import android.util.Log + +/** Controls are vendor control transfers; the HID interrupt endpoint streams IMU reports unprompted. */ +internal class RokidLink private constructor( + private val connection: UsbDeviceConnection, + private val usbInterface: UsbInterface, + private val endpoint: UsbEndpoint, + private val listener: Listener, +) : GlassesLink { + interface Listener { + fun onReady() + fun onValue(message: Int, value: Int) + fun onPose(raw: ByteArray, pose: FloatArray, timeNs: Long) + fun onLost() + } + + @Volatile private var running = true + @Volatile override var ready = false + private set + @Volatile private var tracking = false + private val controlLock = Any() + private lateinit var worker: Thread + override val hasImu = true + + override fun send(msgId: Int, payload: ByteArray): Boolean { + if (!running) return false + val value = payload.firstOrNull()?.toInt()?.and(0xff) ?: -1 + return when (msgId) { + VitureProtocol.MSG_IMU -> (value in 0..1).also { if (it) tracking = value == 1 } + VitureProtocol.MSG_GET_DISPLAY -> display()?.let { listener.onValue(msgId, it) } != null + VitureProtocol.MSG_DISPLAY -> value in RokidModel.MODES && + control(RokidModel.REQUEST_SET_DISPLAY, value, RokidModel.INDEX_DISPLAY) && + true.also { listener.onValue(VitureProtocol.MSG_GET_DISPLAY, value) } + VitureProtocol.MSG_GET_BRIGHTNESS -> read(RokidModel.REQUEST_GET_BRIGHTNESS, RokidModel.INDEX_BRIGHTNESS) + ?.let { listener.onValue(VitureProtocol.MSG_BRIGHTNESS, RokidModel.brightnessStep(it)) } != null + VitureProtocol.MSG_BRIGHTNESS -> value in 0..RokidModel.BRIGHTNESS_STEPS && + control(RokidModel.REQUEST_SET_BRIGHTNESS, RokidModel.brightnessRaw(value), RokidModel.INDEX_BRIGHTNESS) + else -> false // Volume is the glasses' USB audio device; there is no film or IMU-rate control. + } + } + + private fun display(): Int? = read(RokidModel.REQUEST_GET_DISPLAY, RokidModel.INDEX_DISPLAY) + + private fun read(request: Int, index: Int): Int? = synchronized(controlLock) { + if (!running) return null + val buffer = ByteArray(64) + val count = connection.controlTransfer(VENDOR_IN, request, 0, index, buffer, buffer.size, TIMEOUT_MS) + // Display mode is reported in the second byte, brightness in the first. + val offset = if (request == RokidModel.REQUEST_GET_DISPLAY) 1 else 0 + if (count > offset) buffer[offset].toInt() and 0xff else null + } + + private fun control(request: Int, value: Int, index: Int): Boolean = synchronized(controlLock) { + running && connection.controlTransfer(VENDOR_OUT, request, value, index, byteArrayOf(1), 1, TIMEOUT_MS) >= 0 + } + + private fun run() { + val buffer = ByteArray(maxOf(endpoint.maxPacketSize, 64)) + val parser = RokidProtocol.Parser() + var fusion = ImuFusion() + var wasTracking = false + var brightness = -1 + var lastSensor = SystemClock.elapsedRealtime() + try { + ready = true + listener.onReady() + while (running) { + val count = connection.bulkTransfer(endpoint, buffer, buffer.size, 250) + val now = SystemClock.elapsedRealtime() + val sample = if (count > 0) parser.parse(buffer, count) else null + if (sample == null) { + if (now - lastSensor > 3000) error("Rokid IMU stream stalled") + continue + } + lastSensor = now + sample.brightness?.takeIf { it != brightness }?.let { + brightness = it + listener.onValue(VitureProtocol.MSG_BRIGHTNESS, RokidModel.brightnessStep(it)) + } + val enabled = tracking + if (enabled && !wasTracking) fusion = ImuFusion() + wasTracking = enabled + if (!enabled) continue + // Max captures: already right/up/back; level gravity +Y, turn left +gyroY, look up +gyroX, roll right -gyroZ. + fusion.update(sample.timeNs, sample.accel, sample.gyro)?.let { + if (running && tracking) listener.onPose(buffer.copyOf(count), it, SystemClock.elapsedRealtimeNanos()) + } + } + } catch (e: Exception) { + if (running) Log.w(TAG, "Rokid stream failed", e) + } finally { + ready = false + if (running) listener.onLost() + } + } + + override fun close() { + synchronized(controlLock) { + if (!running) return + running = false + } + if (Thread.currentThread() !== worker) worker.join(500) + runCatching { connection.releaseInterface(usbInterface) } + connection.close() + } + + companion object { + private const val TAG = "RokidLink" + private const val TIMEOUT_MS = 250 + private const val VENDOR_IN = UsbConstants.USB_DIR_IN or UsbConstants.USB_TYPE_VENDOR + private const val VENDOR_OUT = UsbConstants.USB_DIR_OUT or UsbConstants.USB_TYPE_VENDOR + + internal fun sensorEndpoint(device: UsbDevice): Pair? { + for (i in 0 until device.interfaceCount) { + val iface = device.getInterface(i) + if (iface.interfaceClass != UsbConstants.USB_CLASS_HID) continue + for (e in 0 until iface.endpointCount) { + val endpoint = iface.getEndpoint(e) + if (endpoint.direction == UsbConstants.USB_DIR_IN && + endpoint.type == UsbConstants.USB_ENDPOINT_XFER_INT) return iface to endpoint + } + } + return null + } + + fun open(usb: UsbManager, device: UsbDevice, listener: Listener): RokidLink? { + val (iface, endpoint) = sensorEndpoint(device) ?: return null + val conn = usb.openDevice(device) ?: return null + if (!conn.claimInterface(iface, true)) { + conn.close() + return null + } + return RokidLink(conn, iface, endpoint, listener).also { link -> + link.worker = Thread({ link.run() }, "rokid-imu").apply { isDaemon = true } + link.worker.start() + } + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/RokidModel.kt b/app/src/main/java/com/droiddeck/launcher/glasses/RokidModel.kt new file mode 100644 index 0000000000..a1ad6e83a1 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/RokidModel.kt @@ -0,0 +1,104 @@ +package com.droiddeck.launcher.glasses + +import java.nio.ByteBuffer +import java.nio.ByteOrder + +/** Rokid Air/Max share one USB identity; the product string distinguishes them. */ +internal class RokidModel private constructor(override val name: String, private val max: Boolean) : GlassesModel { + override val controllable = true + override val brightnessMax = BRIGHTNESS_STEPS + override val volumeMax = 0 + override val hasSunblock = false + override val diagonalFovDeg = if (max) 50f else 43f + override val sbs90 = max + override val rates2d = if (max) listOf(60, 120) else listOf(60) + override val resolutions = if (max) listOf(GlassesResolution(1920, 1080), GlassesResolution(1920, 1200)) + else listOf(GlassesResolution(1920, 1080)) + + override fun mode(hz: Int, sbs: Boolean): Int = mode(hz, sbs, null) + + override fun mode(hz: Int, sbs: Boolean, resolution: GlassesResolution?): Int = when { + !max -> if (sbs) MODE_SBS_1080_60 else MODE_2D_60 + sbs && resolution?.height == 1080 -> MODE_SBS_1080_60 + sbs -> if (hz >= 90) MODE_SBS_1200_90 else MODE_SBS_1200_60 + hz >= 120 -> MODE_2D_120 + else -> MODE_2D_60 + } + + override fun modeForStep(step: Int): Int? = null + + override fun equals(other: Any?) = other is RokidModel && other.name == name && other.max == max + override fun hashCode() = name.hashCode() + + companion object { + const val VENDOR_ID = 0x04d2 + const val PRODUCT_ID = 0x162f + const val BRIGHTNESS_STEPS = 10 + + // Vendor control requests, device recipient. + const val REQUEST_SET_DISPLAY = 0x01 + const val REQUEST_GET_DISPLAY = 0x81 + const val REQUEST_SET_BRIGHTNESS = 0x02 + const val REQUEST_GET_BRIGHTNESS = 0x82 + const val INDEX_DISPLAY = 0x01 + const val INDEX_BRIGHTNESS = 0x02 + + const val MODE_2D_60 = 0 + const val MODE_SBS_1080_60 = 1 + const val MODE_2D_120 = 3 + const val MODE_SBS_1200_90 = 4 + const val MODE_SBS_1200_60 = 5 + val MODES = setOf(MODE_2D_60, MODE_SBS_1080_60, MODE_2D_120, MODE_SBS_1200_90, MODE_SBS_1200_60) + + // 0x04d2 is a shared vendor ID, so the Rokid product string is required too. + fun model(vid: Int, pid: Int, name: String?): GlassesModel? { + if (vid != VENDOR_ID || pid != PRODUCT_ID) return null + val product = name?.trim()?.takeIf { it.startsWith("Rokid", ignoreCase = true) } ?: return null + return RokidModel(product, product.contains("Max", ignoreCase = true)) + } + + fun isDisplay(name: String) = name.contains("Rokid", ignoreCase = true) + + /** Device brightness is 0..100; the shared slider uses ten steps. */ + fun brightnessStep(raw: Int): Int = ((raw.coerceIn(0, 100) + 5) / 10).coerceIn(0, BRIGHTNESS_STEPS) + fun brightnessRaw(step: Int): Int = step.coerceIn(0, BRIGHTNESS_STEPS) * 10 + } +} + +internal object RokidProtocol { + data class Sample(val timeNs: Long, val accel: Vec3, val gyro: Vec3, val brightness: Int?) + + private const val COMBINED = 17 + private const val SEPARATE = 4 + private const val SENSOR_ACCEL = 1 + private const val SENSOR_GYRO = 2 + + /** Max sends one combined report; Air sends accel and gyro reports that share a timestamp. */ + class Parser { + private var accel: Vec3? = null + private var accelTime = -1L + private var gyro: Vec3? = null + private var gyroTime = -2L + + fun parse(packet: ByteArray, length: Int = packet.size): Sample? { + if (length < 64) return null + val b = ByteBuffer.wrap(packet, 0, length).order(ByteOrder.LITTLE_ENDIAN) + return when (packet[0].toInt() and 0xff) { + COMBINED -> Sample(b.getLong(1), vec(b, 9), vec(b, 21), packet[59].toInt() and 0xff) + SEPARATE -> { + val time = b.getLong(9) * 1000 // Air reports microseconds; Max reports nanoseconds. + when (packet[1].toInt() and 0xff) { + SENSOR_ACCEL -> { accel = vec(b, 21); accelTime = time } + SENSOR_GYRO -> { gyro = vec(b, 21); gyroTime = time } + else -> return null + } + if (accelTime != gyroTime) return null + Sample(time, accel!!, gyro!!, null).also { accelTime = -1L; gyroTime = -2L } + } + else -> null + } + } + + private fun vec(b: ByteBuffer, offset: Int) = Vec3(b.getFloat(offset), b.getFloat(offset + 4), b.getFloat(offset + 8)) + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/XrealOrientationFilter.kt b/app/src/main/java/com/droiddeck/launcher/glasses/XrealOrientationFilter.kt index f6ac28f69a..e8d34f44aa 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/XrealOrientationFilter.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/XrealOrientationFilter.kt @@ -4,20 +4,27 @@ import kotlin.math.abs /** 1S radians/sec and device nanoseconds, mapped using directed hardware captures. */ internal class XrealOrientationFilter { + private val fusion = ImuFusion() + + // 1S reports right/down/forward. Rotate 180 degrees about X into the + // shared right/up/back basis before either gravity alignment or fusion. + // Captures: level gravity -Y; looking left -gyroY; up +gyroX; right tilt +gyroZ. + fun update(sample: XrealProtocol.Sample): FloatArray? = fusion.update(sample.timeNs, + Vec3(sample.accel.x, -sample.accel.y, -sample.accel.z), + Vec3(sample.gyro.x, -sample.gyro.y, -sample.gyro.z)) +} + +/** Gyro integration with gravity correction in the shared right/up/back basis, rad/s and device ns. */ +internal class ImuFusion { private var previous = 0L private var rotation = Quaternion.IDENTITY private var initialized = false private var bias = Vec3(0f, 0f, 0f) - fun update(sample: XrealProtocol.Sample): FloatArray? { - if (sample.timeNs <= previous) return null - val dt = if (previous == 0L) 0f else (sample.timeNs - previous) * 1e-9f - previous = sample.timeNs - // 1S reports right/down/forward. Rotate 180 degrees about X into the - // shared right/up/back basis before either gravity alignment or fusion. - // Captures: level gravity -Y; looking left -gyroY; up +gyroX; right tilt +gyroZ. - val accel = Vec3(sample.accel.x, -sample.accel.y, -sample.accel.z) - val gyro = Vec3(sample.gyro.x, -sample.gyro.y, -sample.gyro.z) + fun update(timeNs: Long, accel: Vec3, gyro: Vec3): FloatArray? { + if (timeNs <= previous) return null + val dt = if (previous == 0L) 0f else (timeNs - previous) * 1e-9f + previous = timeNs val norm = accel.length() val gravityValid = abs(norm - 9.81f) < 1.5f if (dt > 0.25f) initialized = false // Never integrate a reconnect/stall as motion. diff --git a/app/src/main/java/com/droiddeck/launcher/gpu/AutoDriverTrial.kt b/app/src/main/java/com/droiddeck/launcher/gpu/AutoDriverTrial.kt index 751ab8298d..a63a802497 100644 --- a/app/src/main/java/com/droiddeck/launcher/gpu/AutoDriverTrial.kt +++ b/app/src/main/java/com/droiddeck/launcher/gpu/AutoDriverTrial.kt @@ -28,7 +28,7 @@ object AutoDriverTrial { release, p.getString("name", "").orEmpty(), p.getString("display", "").orEmpty(), p.getString("linux", "").orEmpty(), p.getString("previousDisplay", "").orEmpty(), p.getString("previousLinux", "").orEmpty(), - p.getInt("starts", 0), + maxOf(p.getInt("starts", 0), p.getInt("displayStarts", 0)), ) } @@ -37,7 +37,7 @@ object AutoDriverTrial { .putString("release", release).putString("name", name) .putString("display", display).putString("linux", linux) .putString("previousDisplay", previousDisplay).putString("previousLinux", previousLinux) - .putInt("starts", 0) + .putInt("starts", 0).putInt("displayStarts", 0) .commit() } @@ -48,13 +48,24 @@ object AutoDriverTrial { fun bad(context: Context): Set = prefs(context).getStringSet("bad", emptySet()).orEmpty() + /** + * Counted before the compositor loads the trial display driver, so a driver that kills the process during + * Vulkan init still counts towards a rollback; sessionStarting runs too late for that. + */ + fun displayStarting(context: Context, display: String) { + val p = prefs(context) + if (p.getString("release", null) == null || p.getString("display", "") != display) return + val counted = maxOf(p.getInt("displayStarts", 0), p.getInt("starts", 0)) + p.edit().putInt("displayStarts", counted + 1).commit() + } + fun sessionStarting(context: Context, display: String, linux: String) { val trial = current(context) watching = null if (trial == null || trial.display != display || trial.linux != linux) return app = context.applicationContext watching = trial - prefs(context).edit().putInt("starts", trial.starts + 1).commit() + prefs(context).edit().putInt("starts", prefs(context).getInt("starts", 0) + 1).commit() } fun sessionReady() { diff --git a/app/src/main/java/com/droiddeck/launcher/input/FakeInputWriter.java b/app/src/main/java/com/droiddeck/launcher/input/FakeInputWriter.java index 308b6add85..05469e6340 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/FakeInputWriter.java +++ b/app/src/main/java/com/droiddeck/launcher/input/FakeInputWriter.java @@ -99,7 +99,8 @@ public class FakeInputWriter { private static final int TRITON_REPORT_OFFSET = TRITON_OFFSET + 24; private static final int TRITON_OUTPUT_SEQ_OFFSET = TRITON_OFFSET + 88; private static final int TRITON_OUTPUT_FEATURE_OFFSET = TRITON_OFFSET + 96; - private static final int TRITON_OUTPUT_LENGTH_OFFSET = TRITON_OFFSET + 100; + private static final int TRITON_OUTPUT_LENGTH_OFFSET = TRITON_OFFSET + 98; + private static final int TRITON_OUTPUT_ACK_OFFSET = TRITON_OFFSET + 100; private static final int TRITON_OUTPUT_OFFSET = TRITON_OFFSET + 104; private static final int TRITON_GET_REQUEST_OFFSET = TRITON_OFFSET + 168; private static final int TRITON_GET_REPLY_OFFSET = TRITON_OFFSET + 176; @@ -229,8 +230,9 @@ public class FakeInputWriter { data.putInt(TRITON_REPORT_ID_OFFSET, 0); data.putInt(TRITON_REPORT_LENGTH_OFFSET, 0); data.putLong(TRITON_OUTPUT_SEQ_OFFSET, 0L); - data.putInt(TRITON_OUTPUT_FEATURE_OFFSET, 0); - data.putInt(TRITON_OUTPUT_LENGTH_OFFSET, 0); + data.putShort(TRITON_OUTPUT_FEATURE_OFFSET, (short) 0); + data.putShort(TRITON_OUTPUT_LENGTH_OFFSET, (short) 0); + data.putInt(TRITON_OUTPUT_ACK_OFFSET, 0); data.putLong(TRITON_GET_REQUEST_OFFSET, 0L); data.putLong(TRITON_GET_REPLY_OFFSET, 0L); } @@ -587,14 +589,18 @@ public class FakeInputWriter { nativeStoreFence(); long seq = ring.getLong(TRITON_OUTPUT_SEQ_OFFSET); if ((seq & 1) != 0 || seq <= lastSequence) return null; - int length = ring.getInt(TRITON_OUTPUT_LENGTH_OFFSET); + int length = ring.getShort(TRITON_OUTPUT_LENGTH_OFFSET) & 0xffff; if (length <= 0 || length > TRITON_REPORT_MAX) return null; byte[] output = new byte[9 + length]; ByteBuffer.wrap(output).order(ByteOrder.LITTLE_ENDIAN).putLong(seq); - output[8] = (byte) (ring.getInt(TRITON_OUTPUT_FEATURE_OFFSET) != 0 ? 1 : 0); + output[8] = (byte) (ring.getShort(TRITON_OUTPUT_FEATURE_OFFSET) != 0 ? 1 : 0); for (int i = 0; i < length; i++) output[9 + i] = ring.get(TRITON_OUTPUT_OFFSET + i); nativeStoreFence(); - return seq == ring.getLong(TRITON_OUTPUT_SEQ_OFFSET) ? output : null; + if (seq != ring.getLong(TRITON_OUTPUT_SEQ_OFFSET)) return null; + // Acknowledge the exact report sequence taken so a concurrent timeout overwrite cannot lose its length. + ring.putInt(TRITON_OUTPUT_ACK_OFFSET, (int) seq); + nativeStoreFence(); + return output; } } diff --git a/app/src/main/java/com/droiddeck/launcher/input/PadBridge.java b/app/src/main/java/com/droiddeck/launcher/input/PadBridge.java index bdc3ff1739..cfb0978cb8 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/PadBridge.java +++ b/app/src/main/java/com/droiddeck/launcher/input/PadBridge.java @@ -55,6 +55,7 @@ public final class PadBridge { private final Handler mainHandler = new Handler(Looper.getMainLooper()); private boolean open; private volatile boolean selectSteam; + private volatile boolean builtinPad = true; private TouchRoute touchRoute; private final PadState routedTouch = new PadState(); private boolean systemGuidePressed; @@ -110,6 +111,35 @@ public final class PadBridge { excluded = devices; } + public synchronized void setBuiltinPad(boolean on) { + boolean changed = builtinPad != on; + builtinPad = on; + if (changed && !on) resetBuiltin(); + } + + private static volatile int firstSlot; + + public static void setFirstSlot(int slot) { + firstSlot = slot; + } + + private int firstPlayerSlot() { + return firstSlot; + } + + private void resetBuiltin() { + routedTouch.clear(); + systemGuidePressed = false; + systemQamPressed = false; + qamTapPressed = false; + qamChordActive = false; + chordButtonPressed = false; + qamChordGeneration++; + chordHandler.removeCallbacksAndMessages(null); + state.clear(); + publish(); + } + public synchronized boolean start() { if (!open) { open = writer.open(); @@ -232,7 +262,9 @@ public final class PadBridge { public synchronized void syncConnectedControllers() { for (int deviceId : InputDevice.getDeviceIds()) { InputDevice device = InputDevice.getDevice(deviceId); - if (isFromController(device) && !excluded.test(deviceId)) publish(slotFor(device)); + if (!isFromController(device) || excluded.test(deviceId)) continue; + int slot = slotFor(device); + if (slot >= 0) publish(slot); } } @@ -252,6 +284,7 @@ public final class PadBridge { public synchronized boolean onKeyEvent(KeyEvent event) { if (!isControllerKeyEvent(event) || excluded.test(event.getDeviceId())) return false; int slot = slotFor(event.getDevice()); + if (slot < 0) return false; int side = JoyCon.side(event.getDevice()); if (side >= 0 && partners[slot] != NO_CONTROLLER && JoyCon.isRail(side, event.getScanCode())) return true; PadState pad = stateFor(slot); @@ -300,6 +333,7 @@ public final class PadBridge { if (!isControllerMotionEvent(event) || excluded.test(event.getDeviceId())) return false; if (event.getAction() != MotionEvent.ACTION_MOVE) return false; int slot = slotFor(event.getDevice()); + if (slot < 0) return false; PadState pad = stateFor(slot); noteDevice(event.getDevice(), slot); statAxes++; @@ -373,6 +407,7 @@ public final class PadBridge { } public synchronized void applyTouch(java.util.function.Consumer mutation) { + if (!builtinPad) return; if (touchRoute != null && touchRoute.active()) { mutation.accept(routedTouch); touchRoute.accept(routedTouch); @@ -412,6 +447,7 @@ public final class PadBridge { } public synchronized void setSystemButtons(boolean guidePressed, boolean qamPressed) { + if (!builtinPad) return; if (systemGuidePressed == guidePressed && systemQamPressed == qamPressed) return; boolean qamStarted = qamPressed && !systemQamPressed; systemGuidePressed = guidePressed; @@ -443,6 +479,7 @@ public final class PadBridge { } public synchronized void triggerQam() { + if (!builtinPad) return; if (!nativeQam()) { startChord(PadState.A); return; @@ -461,6 +498,7 @@ public final class PadBridge { } public synchronized void triggerSteamKeyboard() { + if (!builtinPad) return; startChord(PadState.X); } @@ -510,25 +548,25 @@ public final class PadBridge { if (owners[slot] != NO_CONTROLLER && InputDevice.getDevice(owners[slot]) == null) leave(slot, owners[slot]); } int side = JoyCon.side(device); - for (int slot = 0; side >= 0 && slot < SLOTS; slot++) { + for (int slot = firstPlayerSlot(); side >= 0 && slot < SLOTS; slot++) { if (owners[slot] == NO_CONTROLLER || partners[slot] != NO_CONTROLLER) continue; InputDevice owner = InputDevice.getDevice(owners[slot]); if (JoyCon.side(owner) != 1 - side) continue; partners[slot] = id; slotJoyCons.set(slot * 2 + side, id); slotJoyCons.set(slot * 2 + 1 - side, owner.getId()); - if (slot == 0) releaseBackPaddles(); + if (slot == firstPlayerSlot()) releaseBackPaddles(); stateFor(slot).clear(); Log.i(TAG, "\"" + device.getName() + "\" (id " + id + ") joins \"" + owner.getName() + "\" as player " + (slot + 1)); return slot; } - for (int slot = 0; slot < SLOTS; slot++) { + for (int slot = firstPlayerSlot(); slot < SLOTS; slot++) { if (owners[slot] != NO_CONTROLLER) continue; owners[slot] = id; Log.i(TAG, "\"" + device.getName() + "\" (id " + id + ") is player " + (slot + 1)); return slot; } - return 0; + return -1; } private PadState stateFor(int slot) { @@ -537,7 +575,8 @@ public final class PadBridge { private boolean isPrimary(KeyEvent event) { int id = event.getDevice().getId(); - return owners[0] == id || partners[0] == id; + int first = firstPlayerSlot(); + return owners[first] == id || partners[first] == id; } private void releaseBackPaddles() { @@ -556,7 +595,7 @@ public final class PadBridge { clearJoyCons(slot); if (slotControllers.get(slot) == id) slotControllers.set(slot, owners[slot]); if (activeControllerId == id) activeControllerId = owners[slot]; - if (slot == 0) releaseBackPaddles(); + if (slot == firstPlayerSlot()) releaseBackPaddles(); stateFor(slot).clear(); publish(slot); } @@ -572,8 +611,8 @@ public final class PadBridge { partners[slot] = NO_CONTROLLER; clearJoyCons(slot); slotControllers.set(slot, NO_CONTROLLER); + if (slot == firstPlayerSlot()) releaseBackPaddles(); if (slot == 0) { - releaseBackPaddles(); state.clear(); publish(); return; @@ -632,6 +671,7 @@ public final class PadBridge { } private void publish() { + if (!builtinPad && !open && owners[0] == NO_CONTROLLER && partners[0] == NO_CONTROLLER) return; if (!open && !start()) { statDropped++; return; diff --git a/app/src/main/java/com/droiddeck/launcher/input/SteamControllerBle.kt b/app/src/main/java/com/droiddeck/launcher/input/SteamControllerBle.kt index ee84cffe46..e77b322f2b 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/SteamControllerBle.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/SteamControllerBle.kt @@ -13,6 +13,7 @@ import android.content.Context import android.os.Handler import android.os.HandlerThread import android.util.Log +import com.droiddeck.launcher.session.SessionState import java.nio.ByteBuffer import java.nio.ByteOrder import java.util.ArrayDeque @@ -51,6 +52,10 @@ class SteamControllerBle(private val context: Context) { private fun connect() { if (!running || gatt != null) return + if (SessionState.suspended) { + handler.postDelayed(::connect, RETRY_MS) + return + } val adapter = (context.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager)?.adapter val bonded = runCatching { adapter?.takeIf(BluetoothAdapter::isEnabled)?.bondedDevices } .onFailure { Log.w(TAG, "paired devices unreadable", it) } diff --git a/app/src/main/java/com/droiddeck/launcher/input/SteamTouchBindings.kt b/app/src/main/java/com/droiddeck/launcher/input/SteamTouchBindings.kt index 697b768aa8..9b60e263e2 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/SteamTouchBindings.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/SteamTouchBindings.kt @@ -211,7 +211,7 @@ object SteamTouchBindings { fun libraryDir(context: Context) = File(SteamTouchConfig.steamRoot(context), "tenfoot/resource/images/library/controller/binding_icons") fun gameIconsDir(context: Context, appId: Int): File? = try { - val manifest = File(SteamTouchConfig.steamRoot(context), "steamapps/appmanifest_$appId.acf") + val manifest = File(SteamTouchConfig.steamRoot(context), "steamapps/appmanifest_${SteamTouchConfig.steamId(appId)}.acf") val installDir = KeyValues.parse(manifest.readText()).let { it.child("AppState") ?: it }.string("installdir") installDir?.let { File(SteamTouchConfig.steamRoot(context), "steamapps/common/$it/TouchMenuIcons") }?.takeIf { it.isDirectory } } catch (_: Exception) { diff --git a/app/src/main/java/com/droiddeck/launcher/input/SteamTouchConfig.kt b/app/src/main/java/com/droiddeck/launcher/input/SteamTouchConfig.kt index f1479588c0..1387dce25d 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/SteamTouchConfig.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/SteamTouchConfig.kt @@ -126,7 +126,11 @@ object SteamTouchConfig { } } - private val DEFAULT_SET = setOf(DPAD, A, B, X, Y, SELECT, START) + private val DEFAULT_SET = setOf( + JOYSTICK_LEFT, JOYSTICK_LEFT_BUTTON, JOYSTICK_RIGHT, JOYSTICK_RIGHT_BUTTON, + DPAD, A, B, X, Y, SELECT, START, + BUMPER_LEFT, BUMPER_RIGHT, TRIGGER_LEFT, TRIGGER_RIGHT, + ) private val ALWAYS = setOf(STEAM, THUMB, KEYBOARD) fun steamId(appId: Int): String = Integer.toUnsignedString(appId) diff --git a/app/src/main/java/com/droiddeck/launcher/input/SteamTouchControls.kt b/app/src/main/java/com/droiddeck/launcher/input/SteamTouchControls.kt index 1046e3b343..1c6921a890 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/SteamTouchControls.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/SteamTouchControls.kt @@ -301,9 +301,8 @@ class SteamTouchControls( } } SteamTouchConfig.STEAM -> { - if (pressed) canvas.drawCircle(x, y, r, fill) - canvas.drawCircle(x, y, r, stroke) - drawMark(canvas, x, y, r * 0.5f, if (pressed) Color.argb(alpha, 23, 26, 33) else ink, alpha) + if (isSelected) canvas.drawCircle(x, y, r, stroke) + drawMark(canvas, x, y, r * 0.5f, if (pressed) accent else ink, alpha) } SteamTouchConfig.SELECT, SteamTouchConfig.START -> { val binding = visuals[e.type]?.firstOrNull()?.binding diff --git a/app/src/main/java/com/droiddeck/launcher/input/VrControllers.kt b/app/src/main/java/com/droiddeck/launcher/input/VrControllers.kt new file mode 100644 index 0000000000..343d18bdd4 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/VrControllers.kt @@ -0,0 +1,58 @@ +package com.droiddeck.launcher.input + +import android.content.Context +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import java.io.File + +/** What SteamVR sees for the game pad. The driver reads the file once, when SteamVR starts. */ +object VrControllers { + enum class Emulate(val key: String) { OFF("off"), INDEX("index"), TOUCH("touch"), VIVE("vive") } + + data class Settings(val emulate: Emulate = Emulate.INDEX, val sticksMoveHands: Boolean = false) + + const val FILE = "droiddeck-vr-controllers" + private const val PREFS = "vr_controllers" + + private val _settings = MutableStateFlow(Settings()) + val settings: StateFlow = _settings.asStateFlow() + private var loaded = false + + fun load(context: Context): Settings { + if (!loaded) { + val p = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) + _settings.value = Settings( + emulate = Emulate.entries.firstOrNull { it.key == p.getString("emulate", null) } ?: Emulate.INDEX, + sticksMoveHands = p.getBoolean("sticksMoveHands", false), + ) + loaded = true + } + return _settings.value + } + + fun setEmulate(context: Context, emulate: Emulate) = save(context, load(context).copy(emulate = emulate)) + fun setSticksMoveHands(context: Context, on: Boolean) = save(context, load(context).copy(sticksMoveHands = on)) + + private fun save(context: Context, settings: Settings) { + _settings.value = settings + context.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit() + .putString("emulate", settings.emulate.key) + .putBoolean("sticksMoveHands", settings.sticksMoveHands) + .apply() + publish(context) + } + + fun encode(settings: Settings): String = + "emulate=${settings.emulate.key}\nsticks=${if (settings.sticksMoveHands) "hands" else "game"}\n" + + /** Writes into the session's runtime dir, which the guest sees as /run/droiddeck. */ + fun publish(context: Context) { + runCatching { + val dir = File(context.filesDir, ".wayland-rt").apply { mkdirs() } + val tmp = File(dir, "$FILE.tmp") + tmp.writeText(encode(load(context))) + tmp.renameTo(File(dir, FILE)) + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt b/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt index e7f393fd87..4825646786 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt @@ -181,6 +181,7 @@ object BwrapSpawner { request.optJSONObject("env")?.let { e -> e.keys().forEach { k -> env[k] = e.getString(k) } } if (binds.any { it.guest == "/dev" }) gpu(rootfs, root, env)?.forEach { addBind(it) } preload(session, rootfs, env).forEach { addBind(it) } + zypakShims(binds, root, dir).forEach { addBind(it) } browserSandboxes(env) return Plan(root, binds, request.optString("cwd", "/").ifEmpty { "/" }, argv, env) } @@ -227,6 +228,20 @@ object BwrapSpawner { private const val PRELOAD_DIR = "/run/droiddeck-preload" + private const val ZYPAK_SHIM = "#!/bin/sh\nprogram=\$1\nshift\nexec \"\$program\" --no-sandbox \"\$@\"\n" + + private fun zypakShims(binds: List, root: File, dir: File): List { + val wrappers = listOf("/app/bin/zypak-wrapper.sh", "/app/bin/zypak-wrapper").filter { guest -> + val host = File(hostPath(binds, root.path, guest)) + host.isFile && !Files.isSymbolicLink(host.toPath()) + } + if (wrappers.isEmpty()) return emptyList() + val shim = File(dir, "zypak-wrapper") + shim.writeText(ZYPAK_SHIM) + chmod(shim, 0x1ed) + return wrappers.map { Bind(shim.path, it) } + } + private fun browserSandboxes(env: MutableMap) { env.putIfAbsent("ZYPAK_ZYGOTE_STRATEGY_SPAWN", "0") env.putIfAbsent("QTWEBENGINE_DISABLE_SANDBOX", "1") diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/DeckyManager.kt b/app/src/main/java/com/droiddeck/launcher/runtime/DeckyManager.kt index ba454af7a7..5c5687c967 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/DeckyManager.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/DeckyManager.kt @@ -22,6 +22,7 @@ object DeckyManager { private const val RELEASES = "https://api.github.com/repos/$REPOSITORY/releases?per_page=30" private const val PATH = "root/homebrew/services/PluginLoader" private const val VERSION = "root/homebrew/services/.droiddeck-decky-version" + private const val SETTINGS = "root/homebrew/settings/loader.json" // droiddeck-session reads the marker from the root of the client it runs. private val CEF_REMOTE_DEBUG_MARKERS = listOf( "root/.local/share/Steam/.cef-enable-remote-debugging", @@ -32,7 +33,34 @@ object DeckyManager { private set data class Release(val tag: String, val prerelease: Boolean, val asset: String, val url: String, val digest: String?, val shaUrl: String?, val size: Long, val machine: Int) - data class ReleaseChannels(val stable: List, val prerelease: List) + data class ReleaseChannels(val stable: List, val prerelease: List, val all: List = stable + prerelease) + + const val BRANCH_STABLE = 0 + const val BRANCH_PRERELEASE = 1 + const val BRANCH_TESTING = 2 + + private fun settingsFile(context: Context) = File(LinuxRuntime.rootDir(context), SETTINGS) + + fun branch(context: Context): Int { + val saved = runCatching { JSONObject(settingsFile(context).readText()).optInt("branch", -1) }.getOrDefault(-1) + if (saved >= 0) return saved + val version = File(LinuxRuntime.rootDir(context), VERSION).takeIf { it.isFile }?.readText()?.trim().orEmpty() + return if (version.startsWith("v") && "-pre" in version) BRANCH_PRERELEASE else BRANCH_STABLE + } + + fun setBranch(context: Context, branch: Int) { + val file = settingsFile(context) + val settings = runCatching { JSONObject(file.readText()) }.getOrDefault(JSONObject()) + settings.put("branch", branch) + file.parentFile?.mkdirs() + val staged = File(file.parentFile, "${file.name}.tmp") + staged.writeText(settings.toString(4)) + check(staged.renameTo(file)) { "cannot write ${file.path}" } + } + + // Mirrors Decky's updater: Stable takes the newest non-prerelease tag, Prerelease the newest tag of either kind. + fun latest(channels: ReleaseChannels, branch: Int): Release? = + if (branch == BRANCH_STABLE) channels.stable.firstOrNull() else channels.all.firstOrNull() fun installed(context: Context): String? { val loader = loader(context) @@ -74,17 +102,13 @@ object DeckyManager { } } - fun releases(context: Context, prerelease: Boolean): List { - val channels = releaseChannels(context) - return if (prerelease) channels.prerelease else channels.stable - } - fun releaseChannels(context: Context): ReleaseChannels { val body = Downloader.downloadString(RELEASES) ?: return ReleaseChannels(emptyList(), emptyList()) return try { val array = JSONArray(body) val stable = mutableListOf() val prerelease = mutableListOf() + val all = mutableListOf() for (i in 0 until array.length()) { val release = array.getJSONObject(i) if (release.optBoolean("draft", false)) continue @@ -105,9 +129,11 @@ object DeckyManager { val size = binary.optLong("size", 0) if (size <= 0) continue val row = Release(release.optString("tag_name", "unknown"), isPrerelease, name, url, digest, checksum, size, if (name == "PluginLoader-arm64") 183 else 62) - (if (isPrerelease) prerelease else stable).add(row) + if (!row.tag.startsWith("v")) continue + all.add(row) + (if (isPrerelease || "-pre" in row.tag) prerelease else stable).add(row) } - ReleaseChannels(stable, prerelease) + ReleaseChannels(stable, prerelease, all) } catch (e: Exception) { Log.w(TAG, "release metadata", e); ReleaseChannels(emptyList(), emptyList()) } } diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/DesktopCatalog.kt b/app/src/main/java/com/droiddeck/launcher/runtime/DesktopCatalog.kt index 73e6a75e9c..20714b552c 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/DesktopCatalog.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/DesktopCatalog.kt @@ -118,7 +118,8 @@ object DesktopCatalog { fun desktopPresent(context: Context): Boolean { val root = LinuxRuntime.rootDir(context) - return File(root, DesktopRemoval.PENDING).exists() || marker(context, DESKTOP_ID).exists() + return File(root, DesktopRemoval.PENDING).exists() || marker(context, DESKTOP_ID).exists() || + journal(root, DESKTOP_ID).exists() } fun desktopSize(context: Context): Long = DesktopRemoval.installedSize(context) @@ -126,8 +127,21 @@ object DesktopCatalog { fun cleanLegacy(context: Context, listener: LinuxRuntimeInstaller.ProgressListener? = null) = DesktopRemoval.cleanLegacy(context, listener) - fun removeDesktop(context: Context, listener: LinuxRuntimeInstaller.ProgressListener): String? = + fun removeDesktop(context: Context, listener: LinuxRuntimeInstaller.ProgressListener): String? = synchronized(installLock) { DesktopRemoval.remove(context, listener) + } + + internal fun discardDesktopInstall(context: Context) { + val entry = interrupted(context).firstOrNull { it.id == DESKTOP_ID } + val journal = journal(LinuxRuntime.rootDir(context), DESKTOP_ID) + entry?.let { + val download = downloadFile(context, it) + for (file in listOf(download, File(download.path + ".resume.properties"))) { + check(!file.exists() || file.delete()) { "Could not remove desktop download ${file.name}" } + } + } + check(!journal.exists() || journal.delete()) { "Could not clear desktop installation" } + } fun install(context: Context, entry: Entry, listener: LinuxRuntimeInstaller.ProgressListener?): String? = synchronized(installLock) { installLocked(context, entry, listener) diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/DesktopRemoval.kt b/app/src/main/java/com/droiddeck/launcher/runtime/DesktopRemoval.kt index 3d031a85a7..ff244e6ad2 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/DesktopRemoval.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/DesktopRemoval.kt @@ -44,9 +44,10 @@ internal object DesktopRemoval { val root = LinuxRuntime.rootDir(context) val pending = File(root, PENDING) val marker = File(root, ".droiddeck-pkg-${DesktopCatalog.DESKTOP_ID}") - val version = FileUtils.readString(pending)?.trim() ?: FileUtils.readString(marker)?.trim() + val installing = DesktopCatalog.interrupted(root).firstOrNull { it.id == DesktopCatalog.DESKTOP_ID } + val version = FileUtils.readString(pending)?.trim() ?: installing?.version ?: FileUtils.readString(marker)?.trim() val versions = context.assets.open("desktop-removal/versions.txt").bufferedReader().use { it.readLines() } - check(version in versions) { context.getString(R.string.desktop_removal_unknown) } + check(version in versions && (installing == null || installing.version in versions)) { context.getString(R.string.desktop_removal_unknown) } val entries = lines(context, "kde-remove.tsv.gzip").map(DesktopFileRemoval.Entry::parse) val keep = protected(context, root) cleanLegacy(context, listener) @@ -63,6 +64,7 @@ internal object DesktopRemoval { if (!target.delete()) error("Could not remove $path") } } + DesktopCatalog.discardDesktopInstall(context) if (!pending.delete()) error("Could not finish desktop removal") Log.i("DesktopRemoval", "KDE: $result") listener.onProgress(context.getString(R.string.desktop_removed), 100) diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxNetworkLinkComponent.kt b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxNetworkLinkComponent.kt index 3bf43fc348..ac87bd0aa5 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxNetworkLinkComponent.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxNetworkLinkComponent.kt @@ -104,7 +104,6 @@ class LinuxNetworkLinkComponent( synchronized(lock) { writeNetworkState(currentProperties, currentCapabilities) } } } - wifiReceiver = receiver appContext.registerReceiver(receiver, IntentFilter().apply { addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION) addAction(WifiManager.RSSI_CHANGED_ACTION) @@ -112,6 +111,7 @@ class LinuxNetworkLinkComponent( addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION) addAction(LocationManager.MODE_CHANGED_ACTION) }) + wifiReceiver = receiver scanRequestStamp = File(rootDir, "etc/droiddeck-wifi-scan-request").lastModified() scanHandler.post(scanRequests) requestWifiScan() @@ -119,7 +119,13 @@ class LinuxNetworkLinkComponent( override fun stop() { scanHandler.removeCallbacks(scanRequests) - wifiReceiver?.let { appContext.unregisterReceiver(it) } + wifiReceiver?.let { receiver -> + try { + appContext.unregisterReceiver(receiver) + } catch (e: IllegalArgumentException) { + Log.w(TAG, "Wi-Fi receiver was already gone", e) + } + } wifiReceiver = null val registered = synchronized(lock) { callback.also { callback = null } } ?: return try { diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/UserApps.kt b/app/src/main/java/com/droiddeck/launcher/runtime/UserApps.kt index 3bd000d7d1..b7ca15a18d 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/UserApps.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/UserApps.kt @@ -13,6 +13,7 @@ import com.caverock.androidsvg.SVG import com.droiddeck.launcher.R import com.droiddeck.launcher.core.Downloader import com.droiddeck.launcher.core.FileUtils +import com.droiddeck.launcher.core.Hashes import com.droiddeck.launcher.store.FlathubApi import org.json.JSONArray import org.json.JSONObject @@ -44,7 +45,7 @@ object UserApps { val fex: String = LinuxFex.AUTO, val arch: String? = null, ) - class Release(val tag: String, val published: String, val asset: String, val url: String) + class Release(val tag: String, val published: String, val asset: String, val url: String, val sha256: String? = null) sealed class UpdateCheck { class Current(val tag: String) : UpdateCheck() @@ -318,9 +319,12 @@ object UserApps { val r = releases.getJSONObject(i) if (r.optBoolean("draft")) return@mapNotNull null val assets = r.optJSONArray("assets") ?: return@mapNotNull null - val byName = (0 until assets.length()).associate { j -> assets.getJSONObject(j).let { it.getString("name") to it.getString("browser_download_url") } } + val byName = (0 until assets.length()).associate { j -> assets.getJSONObject(j).let { it.getString("name") to it } } pickAsset(byName.keys.toList())?.let { asset -> - r.optBoolean("prerelease") to Release(r.optString("tag_name", asset), r.optString("published_at"), asset, byName.getValue(asset)) + r.optBoolean("prerelease") to byName.getValue(asset).let { a -> + Release(r.optString("tag_name", asset), r.optString("published_at"), asset, a.getString("browser_download_url"), + Hashes.githubSha256(a.optString("digest"))) + } } } val pick = (candidates.firstOrNull { !it.first } ?: candidates.firstOrNull())?.second @@ -331,7 +335,7 @@ object UserApps { val download = File(context.cacheDir, "github-${release.asset}") try { val label = context.getString(R.string.user_apps_downloading, release.asset) - val ok = Downloader.downloadFile(release.url, download, false) { f -> onProgress(label, if (f < 0) -1 else Math.round(f * 100f)) } + val ok = Downloader.downloadFile(release.url, download, false, release.sha256) { f -> onProgress(label, if (f < 0) -1 else Math.round(f * 100f)) } return if (ok) use(download) else context.getString(R.string.user_apps_download_failed) } finally { download.delete() diff --git a/app/src/main/java/com/droiddeck/launcher/session/ComponentsManager.kt b/app/src/main/java/com/droiddeck/launcher/session/ComponentsManager.kt index 01e6a2fe13..d1aae9d720 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/ComponentsManager.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/ComponentsManager.kt @@ -25,6 +25,8 @@ import java.io.FileOutputStream object ComponentsManager { private const val TAG = "Components" private const val NIGHTLIES = "The412Banner/Nightlies" + private const val DD_COMPONENTS = "Droid-Deck/DroidDeck-Components" + internal const val DD_NIGHTLY = "linux-nightly" private val RELEASES = linkedMapOf( "FexCore-Linux" to "fex", "Dxvk-Linux" to "dxvk", @@ -32,6 +34,10 @@ object ComponentsManager { "Dxvk-gplasync-Linux" to "dxvk", "Vkd3d-proton-Linux" to "vkd3d", ) + // DD_NIGHTLY holds every component in one release; the file name says which. + private val NIGHTLY_PREFIXES = linkedMapOf("DD-dxvk-" to "dxvk", "DD-vkd3d-proton-" to "vkd3d", "DD-FEXCore-" to "fex") + private val SOURCES = RELEASES.keys.map { NIGHTLIES to it } + (DD_COMPONENTS to DD_NIGHTLY) + private val DOWNLOAD_REPOS = listOf(NIGHTLIES, DD_COMPONENTS) private val TYPES = mapOf("FEXCore-Linux" to "fex", "DXVK-Linux" to "dxvk", "VKD3D-Linux" to "vkd3d") private val TYPE_OF = mapOf("fex" to "FEXCore-Linux", "dxvk" to "DXVK-Linux", "vkd3d" to "VKD3D-Linux") val COMPONENTS = listOf("fex", "dxvk", "vkd3d") @@ -815,14 +821,15 @@ object ComponentsManager { if (!force && cache.isFile) runCatching { return parseCatalog(JSONObject(cache.readText())) } if (!force) return Catalog(emptyList(), 0) val items = JSONArray() - for ((tag, comp) in RELEASES) { - val body = Downloader.downloadString("https://api.github.com/repos/$NIGHTLIES/releases/tags/$tag") ?: continue + for ((repo, tag) in SOURCES) { + val body = Downloader.downloadString("https://api.github.com/repos/$repo/releases/tags/$tag") ?: continue val assets = runCatching { JSONObject(body).optJSONArray("assets") }.getOrNull() ?: continue for (i in 0 until assets.length()) { val a = assets.getJSONObject(i) val name = a.optString("name") if (!name.endsWith(".wcp")) continue if (!Hashes.isGithubSha256(a.optString("digest"))) continue + val comp = assetComp(tag, name) ?: continue items.put(JSONObject().put("file", name).put("comp", comp).put("release", tag) .put("url", a.optString("browser_download_url")).put("size", a.optLong("size")).put("digest", a.optString("digest"))) } @@ -837,10 +844,32 @@ object ComponentsManager { val arr = o.optJSONArray("items") ?: JSONArray() val items = (0 until arr.length()).map { arr.getJSONObject(it) }.map { CatalogItem(it.optString("file"), it.optString("comp"), it.optString("release"), it.optString("url"), it.optLong("size"), it.optString("digest")) - }.sortedWith(compareBy { it.comp }.then(newestFirst { it.file })) + }.sortedWith(CATALOG_ORDER) return Catalog(items, o.optLong("fetchedAt")) } + internal fun assetComp(release: String, name: String): String? = + RELEASES[release] ?: if (release == DD_NIGHTLY) NIGHTLY_PREFIXES.entries.firstOrNull { name.startsWith(it.key) }?.value else null + + // Per component: the stable packages newest first, then the nightlies. + internal val CATALOG_ORDER: Comparator = + compareBy { it.comp }.thenBy { it.release == DD_NIGHTLY }.then(newestFirst { it.file }) + + // A nightly DD--[+N]-nightly.wcp pairs with the newest stable -[-]-linux.wcp + // in the same list, so the stable row can offer it behind a Stable/Nightly switch. Unpaired nightlies keep their own row. + internal fun nightlyPairs(items: List): Map { + val stable = items.filter { it.release != DD_NIGHTLY } + return items.filter { it.release == DD_NIGHTLY }.mapNotNull { n -> + val base = n.file.removePrefix("DD-").removeSuffix("-nightly.wcp").substringBefore('+') + val rev = Regex(Regex.escape(base) + "(-\\d+)?-linux\\.wcp") + stable.filter { it.comp == n.comp && rev.matches(it.file) } + .maxWithOrNull { a, b -> ProtonExtras.compareVersions(a.file, b.file) }?.let { it to n } + }.groupBy({ it.first }, { it.second }) + .mapValues { (_, ns) -> ns.maxWith { a, b -> ProtonExtras.compareVersions(a.file, b.file) } } + } + + internal fun allowedDownload(url: String) = DOWNLOAD_REPOS.any { url.startsWith("https://github.com/$it/releases/download/") } + private fun newestFirst(of: (T) -> String): Comparator = Comparator { a, b -> ProtonExtras.compareVersions(of(b), of(a)) } @@ -925,11 +954,13 @@ object ComponentsManager { ): CatalogItem? = catalogMatch(cached(), file, release) ?: catalogMatch(refresh(), file, release) fun download(context: Context, item: CatalogItem, progress: (Int) -> Unit): Package { - require(item.url.startsWith("https://github.com/$NIGHTLIES/releases/download/")) { context.getString(R.string.cmgr_nightlies_only) } + require(allowedDownload(item.url)) { context.getString(R.string.cmgr_nightlies_only) } require(Hashes.isGithubSha256(item.digest)) { context.getString(R.string.cmgr_list_predates_checksums) } val dest = File(packagesDir(context), safeName(item.file)) val part = File(dest.parentFile, dest.name + ".part") - check(Downloader.downloadFile(item.url, part, true, item.digest.substringAfter(':')) { f -> progress(if (f < 0) -1 else (f * 100).toInt().coerceIn(0, 100)) }) { context.getString(R.string.user_apps_download_failed) } + check(Downloader.downloadFile(item.url, part, true, item.digest.substringAfter(':')) { f -> progress(if (f < 0) -1 else (f * 100).toInt().coerceIn(0, 100)) }) { + context.getString(if (item.release == DD_NIGHTLY) R.string.cmgr_nightly_replaced else R.string.user_apps_download_failed) + } if (!Hashes.sha256(part).equals(item.digest.substringAfter(':'), true)) { part.delete(); error(context.getString(R.string.cmgr_checksum_mismatch)) } val info = runCatching { packageInfo(context, part) }.getOrElse { part.delete(); throw it } synchronized(lock) { part.renameTo(dest) } diff --git a/app/src/main/java/com/droiddeck/launcher/session/PerfHud.kt b/app/src/main/java/com/droiddeck/launcher/session/PerfHud.kt index 55ab3f7faf..3829d9a258 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/PerfHud.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/PerfHud.kt @@ -1,6 +1,9 @@ package com.droiddeck.launcher.session import android.content.Context +import android.content.Intent +import android.content.IntentFilter +import android.os.BatteryManager import android.os.Environment import android.os.Handler import android.os.Looper @@ -15,21 +18,35 @@ import com.droiddeck.launcher.wayland.WaylandCompositor import java.io.File import java.util.Locale import java.util.concurrent.atomic.AtomicInteger +import java.util.concurrent.atomic.AtomicLong class PerfHud(context: Context) { var text by mutableStateOf("") private set + var graph by mutableStateOf(FloatArray(0)) + private set private val context = context.applicationContext private val frames = AtomicInteger() private var lastTick = 0L + private var lastFps = 0f private var running = false private val handler = Handler(Looper.getMainLooper()) + private val intervals = FloatArray(GRAPH) + private val graphWrite = AtomicInteger() + private val lastFrameNs = AtomicLong() + + @Volatile private var showFps = true + @Volatile private var showBattery = true + @Volatile private var showGraph = true private val enabled: Boolean get() = SessionPrefs.hudEnabled(context) && !File(Environment.getExternalStorageDirectory(), "Download/droiddeck-no-hud").exists() + private val anyPart: Boolean + get() = showFps || showBattery || showGraph + var onPresentingWindowChanged: (() -> Unit)? = null private var lastWindow: String? = null @@ -40,7 +57,17 @@ class PerfHud(context: Context) { handler.post { onPresentingWindowChanged?.invoke() } } } - override fun onGameFrame() { frames.incrementAndGet() } + override fun onGameFrame() { + frames.incrementAndGet() + if (!showGraph) return + val now = System.nanoTime() + val previous = lastFrameNs.getAndSet(now) + if (previous == 0L) return + val ms = ((now - previous) / 1_000_000f).coerceIn(0f, 50f) + val slot = graphWrite.get() + intervals[slot and (GRAPH - 1)] = ms + graphWrite.compareAndSet(slot, slot + 1) + } } private val tick = object : Runnable { @@ -49,28 +76,82 @@ class PerfHud(context: Context) { val now = SystemClock.elapsedRealtime() val dt = (now - lastTick).coerceAtLeast(1L) / 1000f lastTick = now - text = line(frames.getAndSet(0) / dt) - handler.postDelayed(this, 1000) + lastFps = frames.getAndSet(0) / dt + text = readout(lastFps) + if (showGraph) publishGraph() else clearGraph() + handler.postDelayed(this, TICK_MS) } } fun refresh() { - if (enabled) start() else stop() + readOptions() + if (!enabled || !anyPart) { + stop() + return + } + if (!running) start() else { + if (!showGraph) clearGraph() else publishGraph() + text = readout(lastFps) + } } fun start() { - if (!enabled || running) return + readOptions() + if (!enabled || !anyPart || running) return running = true lastTick = SystemClock.elapsedRealtime() + lastFrameNs.set(0L) frames.set(0) + graphWrite.set(0) WaylandCompositor.setGameListener(listener) - handler.post(tick) + handler.postDelayed(tick, TICK_MS) } fun stop() { running = false + handler.removeCallbacks(tick) WaylandCompositor.clearGameListener(listener) text = "" + graph = FloatArray(0) + } + + private fun readOptions() { + showFps = SessionPrefs.hudShowFps(context) + showBattery = SessionPrefs.hudShowBattery(context) + showGraph = SessionPrefs.hudShowGraph(context) + } + + private fun readout(fpsValue: Float): String { + val parts = ArrayList(2) + if (showFps) parts.add(line(fpsValue)) + if (showBattery) batteryCelsius(readBatteryDeci())?.let { parts.add(it) } + return parts.joinToString("\n") + } + + private fun readBatteryDeci(): Int { + val sticky = runCatching { + context.registerReceiver(null, IntentFilter(Intent.ACTION_BATTERY_CHANGED)) + }.getOrNull() ?: return 0 + return sticky.getIntExtra(BatteryManager.EXTRA_TEMPERATURE, 0) + } + + private fun clearGraph() { + lastFrameNs.set(0L) + graphWrite.set(0) + if (graph.isNotEmpty()) graph = FloatArray(0) + } + + private fun publishGraph() { + val count = graphWrite.get() + val shown = minOf(count, GRAPH) + if (shown < 2) { + graph = FloatArray(0) + return + } + val out = FloatArray(shown) + val start = count - shown + for (i in 0 until shown) out[i] = intervals[(start + i) and (GRAPH - 1)] + graph = out } private fun line(base: Float): String { @@ -91,4 +172,12 @@ class PerfHud(context: Context) { } private fun fps(value: Float) = String.format(Locale.US, "%.0f fps", value) + + companion object { + private const val TICK_MS = 1_000L + private const val GRAPH = 128 + + internal fun batteryCelsius(deci: Int): String? = + if (deci <= 0) null else String.format(Locale.US, "%.1f°C", deci / 10f) + } } diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt index 38b543f936..7495109fa2 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -82,8 +82,10 @@ object SessionFiles { "usr/local/bin/droiddeck-x64-arm-webhelper" to "usr/local/bin/droiddeck-x64-arm-webhelper", "usr/local/bin/droiddeck-x64-webhelper" to "usr/local/bin/droiddeck-x64-webhelper", "usr/local/bin/droiddeck-steamvr" to "usr/local/bin/droiddeck-steamvr", + "usr/local/bin/droiddeck-pipewire" to "usr/local/bin/droiddeck-pipewire", "usr/local/bin/droiddeck-steamvr-settings" to "usr/local/bin/droiddeck-steamvr-settings", "usr/local/bin/droiddeck-steamvr-game" to "usr/local/bin/droiddeck-steamvr-game", + "usr/local/bin/droiddeck-steamvr-flat" to "usr/local/bin/droiddeck-steamvr-flat", "usr/local/bin/droiddeck-bwrap" to "usr/local/bin/droiddeck-bwrap", "usr/local/bin/droiddeck-flatpak" to "usr/local/bin/droiddeck-flatpak", "usr/local/bin/droiddeck-flatpak-setup" to "usr/local/bin/droiddeck-flatpak-setup", @@ -146,6 +148,7 @@ object SessionFiles { val optional = (arrayOf( "usr/local/bin/gamescope" to "usr/local/bin/gamescope", "usr/local/lib/droiddeck/uruntime" to "usr/local/lib/droiddeck/uruntime", + "usr/local/lib/droiddeck-pipewire.tzst" to "usr/local/lib/droiddeck-pipewire.tzst", "usr/local/share/licenses/uruntime/LICENSE" to "usr/local/share/licenses/uruntime/LICENSE", ) + mangoapp + msitools.map { it to it } + vr + fexPreloads).filter { (asset, _) -> val dir = asset.substringBeforeLast('/') diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index e7556e97a5..b548e56ded 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -21,12 +21,14 @@ object SessionPrefs { const val SUSPEND_NEVER = "never" private const val LEGACY_SUSPEND_DOWNLOADS = "downloads" private const val STEAM_DOWNLOADS_IN_BACKGROUND = "steamDownloadsInBackground" + private const val DECKY_ZIP_WARNING_SEEN = "deckyZipWarningSeen" const val CONTROLLER_DECK = "deck" const val CONTROLLER_XBOX360 = "xbox360" const val CONTROLLER_STEAM = "steamcontroller" const val CONTROLLER_DS4 = "dualshock4" const val CONTROLLER_DUALSENSE = "dualsense" + const val CONTROLLER_NONE = "none" const val OSC_AUTO = "auto" const val OSC_ALWAYS = "always" const val OSC_STEAM_QAM = "steam-qam" @@ -49,9 +51,9 @@ object SessionPrefs { ) fun orientation(context: Context): Int = - prefs(context).getInt("orientation", ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE) + prefs(context).getInt("orientation", ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) .takeIf { value -> orientationOptions.any { it.first == value } } - ?: ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE + ?: ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE fun setOrientation(context: Context, orientation: Int) { require(orientationOptions.any { it.first == orientation }) @@ -144,6 +146,13 @@ object SessionPrefs { prefs(context).edit().putString("storesInstallTarget", path).apply() } + /** Empty means follow the app/system language for GOG and Epic installs. */ + fun storesInstallLanguage(context: Context): String = prefs(context).getString("storesInstallLanguage", "") ?: "" + + fun setStoresInstallLanguage(context: Context, code: String) { + prefs(context).edit().putString("storesInstallLanguage", code).apply() + } + fun gameStoresParallel(context: Context): Int = prefs(context).getInt("gameStoresParallel", 1).coerceIn(1, 3) fun setGameStoresParallel(context: Context, count: Int) { @@ -156,6 +165,43 @@ object SessionPrefs { prefs(context).edit().putBoolean(hudKey(context), on).apply() } + fun hudShowFps(context: Context): Boolean = prefs(context).getBoolean("hudFps", true) + + fun setHudShowFps(context: Context, on: Boolean) { + prefs(context).edit().putBoolean("hudFps", on).apply() + } + + fun hudShowBattery(context: Context): Boolean = prefs(context).getBoolean("hudBattery", true) + + fun setHudShowBattery(context: Context, on: Boolean) { + prefs(context).edit().putBoolean("hudBattery", on).apply() + } + + fun hudShowGraph(context: Context): Boolean = prefs(context).getBoolean("hudGraph", true) + + fun setHudShowGraph(context: Context, on: Boolean) { + prefs(context).edit().putBoolean("hudGraph", on).apply() + } + + fun hudColor(context: Context): String = + prefs(context).getString("hudColor", HUD_COLOR_MINT)?.takeIf { it in HUD_COLORS } ?: HUD_COLOR_MINT + + fun setHudColor(context: Context, color: String) { + if (color in HUD_COLORS) prefs(context).edit().putString("hudColor", color).apply() + } + + fun hudOpacity(context: Context): Int = + prefs(context).getInt("hudOpacity", HUD_OPACITY_DEFAULT).takeIf { it in HUD_OPACITY_RANGE } ?: HUD_OPACITY_DEFAULT + + fun setHudOpacity(context: Context, percent: Int) { + prefs(context).edit().putInt("hudOpacity", percent.coerceIn(HUD_OPACITY_RANGE)).apply() + } + + const val HUD_COLOR_MINT = "mint" + val HUD_COLORS = listOf(HUD_COLOR_MINT, "white", "sky", "amber", "violet") + val HUD_OPACITY_RANGE = 30..100 + const val HUD_OPACITY_DEFAULT = 70 + private fun hudKey(context: Context) = if (mangoappSession(context)) "hudDeck" else "hud" private fun mangoappSession(context: Context) = @@ -249,6 +295,16 @@ object SessionPrefs { position.takeIf { it in listOf("top", "bottom", "center") } ?: "center").apply() } + /** + * After a game launched from the front end (or another launcher's link) closes, the client + * exits cleanly and the session returns there, instead of staying in Big Picture. + */ + fun returnAfterGame(context: Context): Boolean = prefs(context).getBoolean("returnAfterGame", true) + + fun setReturnAfterGame(context: Context, on: Boolean) { + prefs(context).edit().putBoolean("returnAfterGame", on).apply() + } + fun stretch16x9(context: Context): Boolean = prefs(context).getBoolean("stretch16x9", false) fun setStretch16x9(context: Context, on: Boolean) { @@ -420,6 +476,8 @@ object SessionPrefs { fun steamController(context: Context): String = prefs(context).getString("steamController", CONTROLLER_DECK) ?: CONTROLLER_DECK fun setSteamController(context: Context, id: String) { prefs(context).edit().putString("steamController", id).apply() } + + fun builtinPad(context: Context): Boolean = steamController(context) != CONTROLLER_NONE fun padType(id: String): Int = when (id) { CONTROLLER_STEAM -> com.droiddeck.launcher.input.FakeInputWriter.PAD_TYPE_STEAM CONTROLLER_XBOX360 -> com.droiddeck.launcher.input.FakeInputWriter.PAD_TYPE_XBOX @@ -953,6 +1011,12 @@ object SessionPrefs { }.apply() } + fun deckyZipWarningSeen(context: Context): Boolean = prefs(context).getBoolean(DECKY_ZIP_WARNING_SEEN, false) + + fun setDeckyZipWarningSeen(context: Context) { + prefs(context).edit().putBoolean(DECKY_ZIP_WARNING_SEEN, true).apply() + } + fun steamDownloadsInBackground(context: Context): Boolean { val prefs = prefs(context) return prefs.getBoolean(STEAM_DOWNLOADS_IN_BACKGROUND, false) || diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt index da3e5b5063..fd9d772701 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -71,6 +71,7 @@ class SessionService : Service() { private val steamDownloadMonitor = SteamDownloadMonitor() private var downloadMonitorTask: Runnable? = null private var downloadActive = false + @Volatile private var steamLibraryMounts = emptyMap() private var suspendDownloadNow = false private var suspendPolicy = SessionPrefs.SUSPEND_MANUAL private var steamDownloadsInBackground = false @@ -92,6 +93,8 @@ class SessionService : Service() { private var suspendAttemptFailed = false private var pendingSteamGameId: String? = null private var pendingSteamGameGeneration = -1 + // Bumped to cancel a running game-exit watch (a new launch, or the session ending). + @Volatile private var gameExitWatchToken = 0 private val flushSteamGame = object : Runnable { override fun run() = flushQueuedSteamGame() } @@ -309,6 +312,8 @@ class SessionService : Service() { val gen = ++sessionGen cancelQueuedSteamGame(clearMailbox = false) clearSteamGameMailbox() + if (SessionState.mode == MODE_STEAM) SessionState.steamUrl + ?.takeIf { it.startsWith(GAME_URL_PREFIX) }?.let { watchGameExit(it.removePrefix(GAME_URL_PREFIX), gen) } acquireLocks() Thread({ OrphanReaper.reap("session starting") @@ -394,6 +399,12 @@ class SessionService : Service() { val fastPathAt = guest.size val pulse = startAudio(guest, sessionDir) + if (steamHere) { + val encoder = VideoEncodeBridge(File(filesDir, "venc/venc.sock")) + encoder.attach(this) + components.add(encoder) + guest.add("BL_VENC_SOCKET=" + encoder.socket.absolutePath) + } guest.add("BL_WIDTH=" + size.first) guest.add("BL_HEIGHT=" + size.second) @@ -702,17 +713,23 @@ class SessionService : Service() { private fun addControllerEnvironment(guest: MutableList, fakeInputDir: File, sessionDir: File) { FakeInputWriter.prepareRingSlots(fakeInputDir, 4) + val builtinPad = SessionPrefs.builtinPad(this) + val hiddenPad = SessionState.mode == MODE_STEAM && !builtinPad && + !com.droiddeck.launcher.input.PadBridge.anyControllerConnected() + com.droiddeck.launcher.input.PadBridge.setFirstSlot(if (hiddenPad) 1 else 0) fakeInputDir.listFiles()?.forEach { file -> val node = Regex("event(\\d+)").matchEntire(file.name)?.groupValues?.get(1)?.toIntOrNull() - if (file.name.startsWith(".uinput-") || (node != null && node >= FIRST_VIRTUAL_PAD)) file.delete() + if (file.name.startsWith(".uinput-") || (node != null && node >= FIRST_VIRTUAL_PAD) || + (hiddenPad && node == 0)) file.delete() } guest.add("FAKE_EVDEV_DIR=" + fakeInputDir.path) val rings = FakeInputWriter.getRingEnv(fakeInputDir) - if (!rings.isNullOrEmpty()) guest.add("FAKE_EVDEV_MEMFD_PATHS=$rings") + val presented = if (hiddenPad) rings?.split(';')?.filterNot { it.startsWith("0=") }?.joinToString(";") else rings + if (!presented.isNullOrEmpty()) guest.add("FAKE_EVDEV_MEMFD_PATHS=$presented") guest.add("FAKE_EVDEV_IDENTITY=xbox360") guest.add("FAKE_EVDEV_VIBRATION=1") val uinput = !File(Environment.getExternalStorageDirectory(), NO_UINPUT_SWITCH).exists() - val wantsDeck = uinput && SessionState.mode == MODE_STEAM && + val wantsDeck = uinput && builtinPad && SessionState.mode == MODE_STEAM && SessionState.steamUi != "desktop" && !File(Environment.getExternalStorageDirectory(), NO_DECK_PAD_SWITCH).exists() val wantsTouch = wantsDeck && !File(Environment.getExternalStorageDirectory(), NO_STEAM_TOUCH_SWITCH).exists() @@ -802,6 +819,7 @@ class SessionService : Service() { File(home, "Storage").mkdirs() binds.add(Environment.getExternalStorageDirectory().path + ":/root/Storage") val library = GameStorage.effective(this) + steamLibraryMounts = emptyMap() var storageDiagnosticLibrary: File? = null if (library != null) { val problem = GameStorage.prepare(this, library.path) @@ -813,6 +831,7 @@ class SessionService : Service() { val content = SecondaryLibrary.contentPath(configured) binds.addAll(SecondaryLibrary.binds(filesDir, configured, content = content)) storageDiagnosticLibrary = content + steamLibraryMounts = SecondaryLibrary.CARD_GUESTS.associateWith { content } val route = if (content === configured) "configured" else "verified-native" Log.i(TAG, "game storage: ${content.path} ($route) -> /mnt/droiddeck-sd (\"${library.label}\"); prefixes and native tools private") } catch (e: Exception) { @@ -1071,9 +1090,71 @@ class SessionService : Service() { pendingSteamGameId = null pendingSteamGameGeneration = -1 SessionEvents.record("steam.game_launch_requested", mapOf("gameId" to gameId, "generation" to gen)) + watchGameExit(gameId, gen) Log.i(TAG, "queued Steam game $gameId for the running client") } + /** + * A game launched from the front end (the Games tab, or another launcher's link): once it has + * started and then been gone for [GAME_EXIT_GRACE_MS], ask the client to exit through the + * session script's steam-stop request. The client quits cleanly, finishing its cloud sync, so + * the session ends on its own and the activity returns to where the launch came from instead + * of leaving the player in Big Picture. The grace covers launchers that restart the game. + */ + private fun watchGameExit(gameId: String, gen: Int) { + if (!SessionPrefs.returnAfterGame(this)) return + val token = ++gameExitWatchToken + Thread({ + val startBy = android.os.SystemClock.elapsedRealtime() + GAME_START_TIMEOUT_MS + var seen = false + var goneSince = 0L + while (token == gameExitWatchToken && gen == sessionGen && SessionState.running && !SessionState.stopRequested) { + val now = android.os.SystemClock.elapsedRealtime() + if (steamGameRunning()) { + if (!seen) Log.i(TAG, "game $gameId started; returning to the launcher when it closes") + seen = true + goneSince = 0L + } else if (!seen) { + // Never started (an install, an update or a failed launch): leave the session be. + if (now > startBy) { + Log.i(TAG, "game $gameId did not start; not watching for its exit") + return@Thread + } + } else if (goneSince == 0L) { + goneSince = now + } else if (now - goneSince >= GAME_EXIT_GRACE_MS) { + mainHandler.post { returnAfterGame(gameId, gen, token) } + return@Thread + } + try { Thread.sleep(GAME_EXIT_POLL_MS) } catch (e: InterruptedException) { return@Thread } + } + }, "game-exit-watch").start() + } + + private fun returnAfterGame(gameId: String, gen: Int, token: Int) { + if (token != gameExitWatchToken || gen != sessionGen || !SessionState.running || + SessionState.stopRequested || SessionState.mode != MODE_STEAM || !SessionPrefs.returnAfterGame(this)) return + val written = runCatching { File(LinuxRuntime.sessionRoot(this), "steam-stop").writeText("") } + .onFailure { Log.w(TAG, "could not ask the client to exit after game $gameId", it) }.isSuccess + if (!written) return + SessionEvents.record("steam.return_after_game", mapOf("gameId" to gameId)) + Log.i(TAG, "game $gameId closed: asking the client to exit and returning to the launcher") + } + + /** A Steam game is running: the client runs each one under its reaper, and Proton's script + * waits on the game with waitforexitandrun. Read from the command lines, as ComponentsManager does. */ + private fun steamGameRunning(): Boolean { + val procs = File("/proc").listFiles() ?: return false + for (p in procs) { + if (!p.name.all(Char::isDigit)) continue + val cmd = runCatching { File(p, "cmdline").readBytes() }.getOrNull() ?: continue + if (cmd.isEmpty()) continue + val text = String(cmd).replace('\u0000', ' ') + if (text.contains("SteamLaunch AppId=") || text.contains("waitforexitandrun")) return true + } + return false + } + private fun resumeSession(panelVisible: Boolean = true) { if (panelVisible) activityVisible = true screenOn = readScreenOn() @@ -1271,13 +1352,13 @@ class SessionService : Service() { private fun updateSuspendPolicy() { if (!SessionState.running) return - if (suspendPolicy == SessionPrefs.SUSPEND_MANUAL && !hasVisibleSurface) { - manualPauseRequested = true - } - val controller = suspendController ?: return val hidden = !hasVisibleSurface val downloadsBlockingSuspend = steamDownloadsInBackground && SessionState.mode == MODE_STEAM && suspendPolicy != SessionPrefs.SUSPEND_NEVER && hidden && downloadActive && !suspendDownloadNow + if (suspendPolicy == SessionPrefs.SUSPEND_MANUAL && hidden && !downloadsBlockingSuspend) { + manualPauseRequested = true + } + val controller = suspendController ?: return if (downloadsBlockingSuspend) acquireLocks() val steamPause = SessionState.mode == MODE_STEAM && !downloadsBlockingSuspend && when (suspendPolicy) { SessionPrefs.SUSPEND_AUTO, SessionPrefs.SUSPEND_NATIVE -> hidden @@ -1473,6 +1554,7 @@ class SessionService : Service() { private fun stopSession(status: Int) { cancelQueuedSteamGame() + gameExitWatchToken++ completeNativeSleep() val (ended, endedArch) = synchronized(stopLock) { if (!SessionState.running) return @@ -1547,7 +1629,6 @@ class SessionService : Service() { } override fun onTaskRemoved(rootIntent: Intent?) { - if (rootIntent?.component?.className == com.droiddeck.launcher.ui.SecondScreenActivity::class.java.name) return if (pipTask || xrActivityVisible) { Log.i(TAG, "panel task dismissed - retaining the session under its active surface policy") activityVisible = false @@ -1712,6 +1793,7 @@ class SessionService : Service() { LinuxRuntime.rootDir(this@SessionService), receivedBytes = TrafficStats.getUidRxBytes(android.os.Process.myUid()), client = SessionState.steamClientArch, + mounts = steamLibraryMounts, ) if (wasActive != downloadActive) refreshNotification() updateSuspendPolicy() @@ -1730,7 +1812,9 @@ class SessionService : Service() { pads.add(String.format(java.util.Locale.ROOT, "\"%s\" (%04x:%04x)", d.name, d.vendorId, d.productId)) } Log.i(TAG, "controllers at start: " + (if (pads.isEmpty()) "none" else pads.joinToString(", ")) + - "; presented to the guest as " + if (SessionState.deckPad) "switchable, starting as " + SessionPrefs.steamController(this) else "an Xbox 360 controller") + "; presented to the guest as " + if (SessionState.deckPad) "switchable, starting as " + SessionPrefs.steamController(this) + else if (SessionState.mode == MODE_STEAM && !SessionPrefs.builtinPad(this)) "one per connected controller, no built-in pad" + else "an Xbox 360 controller") } companion object { @@ -1775,6 +1859,12 @@ class SessionService : Service() { private const val GAME_LAUNCH_RETRY_MS = 250L private const val DOWNLOAD_POLL_MS = 2_000L private const val STEAM_GAME_REQUEST = "steam-game" + private const val GAME_URL_PREFIX = "steam://rungameid/" + /** How long a front-end launch may take to start (downloads, first-run installs) before the exit watch gives up. */ + private const val GAME_START_TIMEOUT_MS = 20 * 60_000L + /** How long the game must stay gone before the client is asked to exit: launchers restart games. */ + private const val GAME_EXIT_GRACE_MS = 10_000L + private const val GAME_EXIT_POLL_MS = 2_000L private const val NO_PAD_SWITCH = "Download/droiddeck-no-pad" private const val NO_UINPUT_SWITCH = "Download/droiddeck-no-uinput" private const val NO_DECK_PAD_SWITCH = "Download/droiddeck-no-deck-pad" diff --git a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt index 78bbc89cd6..8fdbf5d244 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SettingsReset.kt @@ -13,7 +13,8 @@ object SettingsReset { internal val SESSION_KEYS = setOf( "orientation", "launcherFullscreen", "animations", "theme", "runSteamAtStartup", "addedGamesArt", "gameStoresEnabled", "gameStoresSpeedTier", "gameStoresParallel", "storesOpenTab", "storesShowMature", - "hud", "hudDeck", "backActionsInverted", "touch", "osc", "shape", "steamController", + "storesInstallLanguage", + "hud", "hudDeck", "hudFps", "hudBattery", "hudGraph", "hudColor", "hudOpacity", "backActionsInverted", "touch", "osc", "shape", "steamController", "gamepadLeft", "gamepadRight", "pipAutoEnter", "unfoldedControls", "stretch16x9", "picturePosition", "gpuDriverMode", "androidDriver", "linuxDriver", "linuxDriver.steam", "linuxDriver.desktop", "tuSysmem", "glThread", "noGlError", "zinkLazy", "mangoapp", "gpuClockPin", "gamescopeRealtime", diff --git a/app/src/main/java/com/droiddeck/launcher/session/SteamDownloadMonitor.kt b/app/src/main/java/com/droiddeck/launcher/session/SteamDownloadMonitor.kt index 2558bfe945..37f7c1fb90 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SteamDownloadMonitor.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SteamDownloadMonitor.kt @@ -18,8 +18,9 @@ internal class SteamDownloadMonitor { private var lastReceivedBytes = -1L private var lastReceivedAt = 0L - fun poll(runtimeRoot: File, now: Long = System.currentTimeMillis(), receivedBytes: Long = -1L, client: String? = null): Boolean { - val current = manifests(runtimeRoot).associate { it.path to read(it) } + fun poll(runtimeRoot: File, now: Long = System.currentTimeMillis(), receivedBytes: Long = -1L, client: String? = null, + mounts: Map = emptyMap()): Boolean { + val current = manifests(runtimeRoot, mounts).associate { it.path to read(it) } val progressed = current.any { (path, state) -> state.incomplete && state.bytesDownloaded > (previous[path]?.bytesDownloaded ?: state.bytesDownloaded) } @@ -98,7 +99,7 @@ internal class SteamDownloadMonitor { now - lastContentActivityAt <= CONTENT_ACTIVITY_GRACE_MS } - private fun manifests(runtimeRoot: File): List { + private fun manifests(runtimeRoot: File, mounts: Map): List { val steamRoots = linkedSetOf() for (home in STEAM_HOMES) { val primary = File(runtimeRoot, home) @@ -106,7 +107,7 @@ internal class SteamDownloadMonitor { val libraryFolders = File(primary, "steamapps/libraryfolders.vdf") runCatching { PATH.findAll(libraryFolders.readText()).forEach { match -> - steamRoots += File(runtimeRoot, match.groupValues[1].removePrefix("/")) + steamRoots += hostPath(runtimeRoot, match.groupValues[1], mounts) } } } @@ -117,6 +118,15 @@ internal class SteamDownloadMonitor { } } + private fun hostPath(runtimeRoot: File, guest: String, mounts: Map): File { + val path = guest.trimEnd('/') + for ((mount, host) in mounts) { + if (path == mount) return host + if (path.startsWith("$mount/")) return File(host, path.removePrefix("$mount/")) + } + return File(runtimeRoot, path.removePrefix("/")) + } + private fun read(file: File): ManifestState { val text = runCatching { file.readText() }.getOrDefault("") val flags = value(text, "StateFlags")?.toLongOrNull() ?: 0L diff --git a/app/src/main/java/com/droiddeck/launcher/session/VideoEncodeBridge.kt b/app/src/main/java/com/droiddeck/launcher/session/VideoEncodeBridge.kt new file mode 100644 index 0000000000..8e4b247307 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/session/VideoEncodeBridge.kt @@ -0,0 +1,28 @@ +package com.droiddeck.launcher.session + +import android.util.Log +import com.droiddeck.launcher.core.SessionPart +import java.io.File + +/** Steam's Remote Play V4L2 encoder in the guest talks to this MediaCodec encoder (venc.c, venc_server.cpp). */ +class VideoEncodeBridge(val socket: File) : SessionPart() { + override fun start() { + socket.parentFile?.mkdirs() + val ok = runCatching { System.loadLibrary("ddvenc"); nativeStart(socket.absolutePath) } + .onFailure { Log.w(TAG, "hardware video encoding unavailable", it) } + .getOrDefault(false) + Log.i(TAG, if (ok) "Remote Play hardware encoding on at $socket" else "Remote Play hardware encoding off") + } + + override fun stop() { + runCatching { nativeStop() } + socket.delete() + } + + private external fun nativeStart(path: String): Boolean + private external fun nativeStop() + + private companion object { + const val TAG = "VideoEncodeBridge" + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/session/WinComponents.kt b/app/src/main/java/com/droiddeck/launcher/session/WinComponents.kt index c79171df26..2c5a1aa0d1 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/WinComponents.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/WinComponents.kt @@ -369,7 +369,9 @@ object WinComponents { val archiveName = archive.optString("name") val url = c.snapshot.substringBeforeLast('/') + "/" + archiveName val file = File(work, "${c.name}.files.tar.xz") - if (!Downloader.downloadFile(url, file, false) { f -> onProgress(Progress(c.name, archiveName, Phase.DOWNLOAD, if (f < 0) -1 else Math.round(f * 100f))) }) { + // The snapshot came straight from github.com, so its digest may vouch for a mirror's copy of the archive. + val sha = archive.optString("sha256").takeIf { it.matches(Regex("(?i)[0-9a-f]{64}")) } + if (!Downloader.downloadFile(url, file, false, sha) { f -> onProgress(Progress(c.name, archiveName, Phase.DOWNLOAD, if (f < 0) -1 else Math.round(f * 100f))) }) { return null to "download failed: $archiveName" } archive.optString("sha256").takeIf { it.length == 64 }?.let { sha -> diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreCatalog.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreCatalog.kt index 6f4678c7f7..debaf4ad04 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreCatalog.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreCatalog.kt @@ -22,8 +22,11 @@ data class CatalogItem( val extra: Map = emptyMap(), val mature: Boolean = false, val subscription: Boolean = false, + val includedWith: String = "", ) { val accessible: Boolean get() = owned || subscription + /** Licensed now, or a supported package the account's subscription can install. */ + val installable: Boolean get() = accessible || includedWith.isNotBlank() val isDiscounted: Boolean get() = discountPercent > 0 && originalPrice.isNotBlank() val key: String get() = "${store.id}:$id" } @@ -86,6 +89,18 @@ internal fun retainCatalogOrder(items: List, previous: List, + found: List, + shelves: StoreShelves?, +): CatalogItem? = + library.firstOrNull { it.store == store && it.id == id } + ?: found.firstOrNull { it.store == store && it.id == id } + ?: shelves?.all?.firstOrNull { it.store == store && it.id == id } + fun mergeItems(old: List?, new: List): List { if (old.isNullOrEmpty()) return new val before = old.associateBy { it.key } @@ -93,6 +108,19 @@ fun mergeItems(old: List?, new: List): List?, patched: List): List { + if (old.isNullOrEmpty()) return patched + val byKey = patched.associateBy { it.key } + val kept = old.map { byKey[it.key] ?: it } + val added = patched.filter { n -> old.none { it.key == n.key } } + return if (added.isEmpty()) kept else (kept + added).sortedBy { it.title.lowercase() } +} + class InstalledStoreGame(val sidecar: StoreGameSidecar, val folder: java.io.File) { val key: String get() = "${sidecar.store.id}:${sidecar.id}" } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreLanguage.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreLanguage.kt new file mode 100644 index 0000000000..bc9afe3c21 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreLanguage.kt @@ -0,0 +1,160 @@ +package com.droiddeck.launcher.stores + +import android.content.Context +import com.droiddeck.launcher.core.AppLanguage +import com.droiddeck.launcher.session.SessionPrefs +import org.json.JSONArray +import java.util.Locale + +/** + * Language for a third-party store install ([Store.GOG], [Store.EPIC]): the app/system locale by + * default, or the code the user picked in the install dialog / store settings. + * + * GOG depots and Epic install tags use overlapping but not identical codes (`en` vs `en-US`, + * `nb` vs `no`). Matching is on the language part plus a few aliases, so a Polish phone selects + * `pl-PL` depots without the user having to know the store's spelling. + */ +object StoreLanguage { + const val EXTRA = "installLanguage" + + /** Codes the settings list and Epic's tag table share; GOG often uses the same with a region. */ + val KNOWN: List = listOf( + "en", "pl", "de", "fr", "es", "es-419", "pt", "pt-BR", "it", "ru", "uk", "cs", "hu", + "nl", "sv", "da", "fi", "nb", "ro", "bg", "el", "tr", "ar", "th", "vi", "ja", "ko", + "zh-Hans", "zh-Hant", + ) + + private val ALIASES = mapOf( + "english" to "en", "polish" to "pl", "german" to "de", "french" to "fr", "spanish" to "es", + "italian" to "it", "russian" to "ru", "ukrainian" to "uk", "czech" to "cs", "hungarian" to "hu", + "dutch" to "nl", "swedish" to "sv", "danish" to "da", "finnish" to "fi", "norwegian" to "nb", + "no" to "nb", "romanian" to "ro", "bulgarian" to "bg", "greek" to "el", "turkish" to "tr", + "arabic" to "ar", "thai" to "th", "vietnamese" to "vi", "japanese" to "ja", "korean" to "ko", + "schinese" to "zh-hans", "tchinese" to "zh-hant", "chinese" to "zh-hans", + "brazilian" to "pt-br", "portuguese" to "pt", + ) + + fun selectable(store: Store): Boolean = store == Store.GOG || store == Store.EPIC + + /** Tag actually sent to the store: settings override, else the app/system locale. */ + @JvmStatic + fun preferredCode(context: Context): String { + val chosen = SessionPrefs.storesInstallLanguage(context) + if (chosen.isNotEmpty()) return chosen + return tagFor(AppLanguage.effective(context)) + } + + @JvmStatic + fun preferredCode(): String = tagFor(Locale.getDefault()) + + fun tagFor(locale: Locale): String { + val language = locale.language.ifEmpty { "en" } + val country = locale.country + val script = locale.script + return when { + language == "zh" && (script == "Hant" || country == "TW" || country == "HK" || country == "MO") -> "zh-Hant" + language == "zh" -> "zh-Hans" + language == "pt" && (country.isEmpty() || country == "BR") -> "pt-BR" + language == "es" && country.isNotEmpty() && country != "ES" -> "es-419" + country.isNotEmpty() -> "$language-$country" + else -> language + } + } + + fun localeFor(code: String?, context: Context): Locale { + val tag = code?.takeIf { it.isNotBlank() } ?: preferredCode(context) + return Locale.forLanguageTag(tag.replace('_', '-')) + } + + fun fallbackList(store: Store): List = if (selectable(store)) KNOWN else emptyList() + + /** + * One code from [available]. An exact normalized code wins (`pl-PL` over `pl`). A base-language + * match is used only when that exact code is not offered, then English, then the first code. + */ + @JvmStatic + fun pick(available: List, preferred: String): String { + if (available.isEmpty()) return preferred + val want = primary(preferred) ?: return available.first() + return available.firstOrNull { primary(it) == want } + ?: available.firstOrNull { depotAccepted(arrayOf(it), preferred) } + ?: available.firstOrNull { depotAccepted(arrayOf(it), "en") } + ?: available.first() + } + + /** + * True when a GOG depot whose `languages` array is [listed] overlaps [chosen], including a + * base-language match (`pl` accepts `pl-PL`). Shared depots (`*`, empty, missing) always match. + * Install selection uses [depotMatchesResolved] after [pick] has chosen a single code. + */ + @JvmStatic + fun depotAccepted(listed: Array?, chosen: String): Boolean { + if (listed.isNullOrEmpty()) return true + val want = tokens(chosen) + return listed.any { have -> + val parts = tokens(have) + parts.contains("*") || parts.any { it in want } + } + } + + /** + * True when [listed] is shared, or contains the one code [resolved] already selected. + * `pl-PL` does not also keep a `pl` depot. + */ + @JvmStatic + fun depotMatchesResolved(listed: Array?, resolved: String): Boolean { + if (listed.isNullOrEmpty()) return true + if (listed.any { it.trim() == "*" }) return true + val want = primary(resolved) ?: return false + return listed.any { primary(it) == want } + } + + /** Normalized code without collapsing to the base language. `pl-PL` stays `pl-pl`. */ + internal fun primary(code: String): String? { + val raw = code.trim().lowercase().replace('_', '-') + if (raw.isEmpty()) return null + if (raw == "*") return "*" + return ALIASES[raw] ?: raw + } + + @JvmStatic + fun codesFromDepots(depots: JSONArray?): List { + if (depots == null) return emptyList() + val seen = LinkedHashSet() + for (i in 0 until depots.length()) { + val langs = depots.optJSONObject(i)?.optJSONArray("languages") ?: continue + for (j in 0 until langs.length()) { + val raw = langs.optString(j, "").trim() + if (raw.isEmpty() || raw == "*") continue + val key = raw.lowercase() + if (seen.none { it.lowercase() == key }) seen.add(raw) + } + } + return seen.toList() + } + + fun displayName(code: String): String { + if (code.isEmpty()) return "" + val locale = Locale.forLanguageTag(code.replace('_', '-')) + AppLanguage.supportedTag(locale)?.let { return AppLanguage.nativeName(it) } + val name = locale.getDisplayName(locale) + return name.replaceFirstChar { if (it.isLowerCase()) it.titlecase(locale) else it.toString() } + } + + internal fun tokens(code: String): Set { + val raw = code.trim().lowercase().replace('_', '-') + if (raw.isEmpty()) return emptySet() + if (raw == "*") return setOf("*") + val mapped = ALIASES[raw] ?: raw + val lang = mapped.substringBefore('-').let { ALIASES[it] ?: it } + val out = mutableSetOf(mapped, lang) + if (mapped.startsWith("zh-hant") || mapped == "zh-tw" || mapped == "zh-hk") { + out.add("zh-hant"); out.add("zh") + } + if (mapped.startsWith("zh-hans") || mapped == "zh-cn") { + out.add("zh-hans"); out.add("zh") + } + if (mapped == "pt-br" || mapped == "br") out.add("pt-br") + return out + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreNet.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreNet.kt index 8517a1aa0f..f3a4e495f8 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreNet.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreNet.kt @@ -25,7 +25,7 @@ internal object StoreNet { headers.forEach { (k, v) -> setRequestProperty(k, v) } } val code = conn.responseCode - if (code !in 200..299) { Log.w(TAG, "GET $code ${StoreLog.redactUrl(url)}"); null } else readAll(conn) + if (code !in 200..299) { StoresState.logLine("GET $code ${StoreLog.redactUrl(url)}"); null } else readAll(conn) } catch (e: Exception) { Log.w(TAG, "GET failed ${StoreLog.redactUrl(url)}: ${e.javaClass.simpleName}") null diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreSizes.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreSizes.kt index b9b9354b7d..454e3d23bc 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreSizes.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreSizes.kt @@ -99,7 +99,10 @@ object StoreSizes { val json = EpicApiClient.getManifestApiJson(token, ns, catalogItemId, item.id) ?: return 0L val bytes = EpicDownloadManager.downloadManifest(json, EpicDownloadManager.parseCdnUrls(json)) ?: return 0L val manifest = EpicDownloadManager.parseManifest(bytes) ?: return 0L - EpicDownloadManager.resolveInstallFiles(manifest, EpicInstallTags.tagsForDevice()).sumOf { it.fileSize() } + EpicDownloadManager.resolveInstallFiles( + manifest, + EpicInstallTags.tagsFor(StoreLanguage.localeFor(null, context)), + ).sumOf { it.fileSize() } } Store.AMAZON -> { val token = AmazonCredentialStore.getValidAccessToken(context) ?: return 0L diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt index dbeb94e238..e780733d97 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoresState.kt @@ -128,6 +128,10 @@ object StoresState { fun installedGame(store: Store, id: String): InstalledStoreGame? = installed.firstOrNull { it.sidecar.store == store && it.sidecar.id == id } + fun detailItem(store: Store, id: String): CatalogItem? = detailCatalogItem( + store, id, library[store].orEmpty(), found[store].orEmpty(), shelves[store], + ) + fun open(context: Context, store: Store, force: Boolean = false) { val backend = backends[store] ?: return val app = context.applicationContext @@ -198,32 +202,35 @@ object StoresState { askForNotifications(context) if (isUnfinished(item)) { install(context, item); return } val targets = StoreInstallRoot.targets(context) - if (targets.size > 1) pendingInstall = item else install(context, item, targets.first().root) + if (targets.size > 1 || StoreLanguage.selectable(item.store)) pendingInstall = item + else install(context, item, targets.first().root) } - fun install(context: Context, item: CatalogItem, root: java.io.File? = null) { + fun install(context: Context, item: CatalogItem, root: java.io.File? = null, language: String? = null) { val app = context.applicationContext val folder = StoreInstallRoot.folderFor(app, item.store, item.id, item.title, root ?: StoreInstallRoot.installRoot(app)) val target = folder.parentFile!!.parentFile!! - val check = StoreInstallRoot.checkStorage(app, item, target) + val code = language?.takeIf { it.isNotBlank() } ?: StoreLanguage.preferredCode(app) + val tagged = if (StoreLanguage.selectable(item.store)) item.copy(extra = item.extra + (StoreLanguage.EXTRA to code)) else item + val check = StoreInstallRoot.checkStorage(app, tagged, target) if (!check.enough) { val errorMsg = check.errorMessage ?: app.getString(com.droiddeck.launcher.R.string.stores_storage_insufficient, formatBytes(check.requiredBytes), formatBytes(check.availableBytes)) val entry = com.droiddeck.launcher.stores.download.DownloadEntry( - item.store, - item.id, - item.title, - cover = item.imageUrl, - bytesTotal = item.sizeBytes, + tagged.store, + tagged.id, + tagged.title, + cover = tagged.imageUrl, + bytesTotal = tagged.sizeBytes, location = StoreInstallRoot.labelFor(app, folder) ) - com.droiddeck.launcher.stores.download.SavedQueue.remember(app, item, target) + com.droiddeck.launcher.stores.download.SavedQueue.remember(app, tagged, target) com.droiddeck.launcher.stores.download.DownloadQueue.recordFailed(app, entry, errorMsg) { - install(app, item, target) + install(app, tagged, target, code) } return } - com.droiddeck.launcher.stores.download.SavedQueue.remember(app, item, target) - backends[item.store]?.install(app, item, target) ?: logLine("${item.store.label}: this build cannot install yet") + com.droiddeck.launcher.stores.download.SavedQueue.remember(app, tagged, target) + backends[tagged.store]?.install(app, tagged, target) ?: logLine("${tagged.store.label}: this build cannot install yet") } val uninstalling = mutableStateMapOf() diff --git a/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicInstallTags.kt b/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicInstallTags.kt index 8d1018c540..3566e37ad4 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicInstallTags.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicInstallTags.kt @@ -8,17 +8,20 @@ object EpicInstallTags { @Volatile private var last: Answer? = null - private fun current(): Answer? { - val locale = Locale.getDefault() + private fun answer(locale: Locale): Answer? { last?.takeIf { it.locale == locale }?.let { return it } - val answer = EpicNative.call("locale", JSONObject().put("language", locale.language).put("region", locale.country)) ?: return null - val list = answer.optJSONArray("tags") + val call = EpicNative.call("locale", JSONObject().put("language", locale.language).put("region", locale.country)) ?: return null + val list = call.optJSONArray("tags") val tags = List(list?.length() ?: 0) { list!!.optString(it) }.filter { it.isNotEmpty() } - return Answer(locale, tags, answer.optString("launchLocale", "en").ifEmpty { "en" }).also { last = it } + return Answer(locale, tags, call.optString("launchLocale", "en").ifEmpty { "en" }).also { last = it } } - @JvmStatic - fun tagsForDevice(): List = current()?.tags ?: emptyList() + fun tagsFor(locale: Locale): List = answer(locale)?.tags ?: emptyList() - fun launchLocale(): String = current()?.launchLocale ?: "en" + fun launchLocale(locale: Locale): String = answer(locale)?.launchLocale ?: "en" + + @JvmStatic + fun tagsForDevice(): List = tagsFor(Locale.getDefault()) + + fun launchLocale(): String = launchLocale(Locale.getDefault()) } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicInstaller.kt b/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicInstaller.kt index ee6a2181d0..8d40d002bf 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicInstaller.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/epic/EpicInstaller.kt @@ -9,6 +9,7 @@ import com.droiddeck.launcher.stores.StoreExe import com.droiddeck.launcher.stores.StoreGameSidecar import com.droiddeck.launcher.stores.StoreInstallRoot import com.droiddeck.launcher.stores.StoreInstalls +import com.droiddeck.launcher.stores.StoreLanguage import com.droiddeck.launcher.stores.download.DownloadQueue import com.droiddeck.launcher.stores.download.DownloadStage import com.droiddeck.launcher.stores.download.StoreDownloadTier @@ -29,6 +30,8 @@ internal class EpicInstaller( private fun scratch(): File = StoreInstallRoot.scratchDir(app, Store.EPIC, item.id) + private fun installLocale() = StoreLanguage.localeFor(item.extra[StoreLanguage.EXTRA], app) + override fun run(handle: DownloadQueue.JobHandle): String? { handle.stage(DownloadStage.MANIFEST, app.getString(R.string.stores_sync_sign_in)) val token = EpicCredentialStore.getValidAccessToken(app) ?: throw IllegalStateException("Not signed in to Epic Games") @@ -47,7 +50,7 @@ internal class EpicInstaller( .put("gameDir", folder.absolutePath) .put("scratchDir", if (StoreInstallRoot.isRemovable(app, folder)) scratch().absolutePath else "") .put("storageLabel", StoreInstallRoot.labelFor(app, folder)) - .put("tags", JSONArray(EpicInstallTags.tagsForDevice())) + .put("tags", JSONArray(EpicInstallTags.tagsFor(installLocale()))) .put("maxWorkers", tier.networkWindow.coerceIn(1, 128)) .put("processWorkers", tier.processWorkers) .put("caBundle", "") @@ -111,7 +114,7 @@ internal class EpicInstaller( val argsAnswer = EpicNative.call( "launch.args", JSONObject().put("displayName", creds?.displayName.orEmpty()).put("accountId", creds?.accountId.orEmpty()) - .put("namespace", namespace).put("locale", EpicInstallTags.launchLocale()).put("appName", item.id) + .put("namespace", namespace).put("locale", EpicInstallTags.launchLocale(installLocale())).put("appName", item.id) .put("deploymentId", deployment).put("additional", additional), ) val argList = argsAnswer?.optJSONArray("args") @@ -122,6 +125,7 @@ internal class EpicInstaller( extra["namespace"] = namespace extra["catalogItemId"] = catalogItemId if (deployment.isNotEmpty()) extra["deploymentId"] = deployment + extra[StoreLanguage.EXTRA] = item.extra[StoreLanguage.EXTRA] ?: StoreLanguage.preferredCode(app) extra[WinCompSources.EPIC_PREREQ_PATH] = result.optString("prereqPath") extra[WinCompSources.EPIC_PREREQ_NAME] = result.optString("prereqName") if (result.optBoolean("prereqRead", false)) extra[WinCompSources.LIST_READ] = "1" diff --git a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogBackend.kt b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogBackend.kt index 1676ef9dbe..2825530d4e 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogBackend.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogBackend.kt @@ -9,6 +9,7 @@ import com.droiddeck.launcher.stores.StoreBackend import com.droiddeck.launcher.stores.StoreGameSidecar import com.droiddeck.launcher.stores.StoreInstallRoot import com.droiddeck.launcher.stores.StoreInstalls +import com.droiddeck.launcher.stores.StoreLanguage import com.droiddeck.launcher.stores.StoreLoginActivity import com.droiddeck.launcher.stores.StoresState import com.droiddeck.launcher.stores.download.DownloadEntry @@ -37,7 +38,16 @@ object GogBackend : StoreBackend { if (cached.isNotEmpty()) StoresState.library[store] = com.droiddeck.launcher.stores.mergeItems(StoresState.library[store], cached) if (!quiet) StoresState.status[store] = app.getString(com.droiddeck.launcher.R.string.stores_sync_library) } - val result = GogLibrary.sync(app, force) { line -> if (!quiet) StoresState.post { StoresState.status[store] = line } } + val result = GogLibrary.sync(app, force, onStatus = { line -> if (!quiet) StoresState.post { StoresState.status[store] = line } }, onList = { list -> + // Mapped here, off the main thread: the listing paints the tab before any product is asked about. + val items = list.map { GogLibrary.toCatalogItem(app, it) } + // An empty listing is not news: posting it would drop the cards already on screen. + if (items.isNotEmpty()) StoresState.post { StoresState.library[store] = com.droiddeck.launcher.stores.mergeItems(StoresState.library[store], items) } + }, onItems = { changed -> + // Only the products that came back are touched: a card already on screen keeps its object, and a product the grid has not seen yet is added where its title belongs. + val items = changed.map { GogLibrary.toCatalogItem(app, it) } + StoresState.post { StoresState.library[store] = com.droiddeck.launcher.stores.patchItems(StoresState.library[store], items) } + }) StoresState.post { StoresState.status.remove(store) when (result) { @@ -82,6 +92,7 @@ object GogBackend : StoreBackend { handle.stage(DownloadStage.MANIFEST) StoreInstalls.begin(folder, Store.GOG, game.gameId, game.title, item.tallImageUrl ?: item.imageUrl, item.imageUrl) var downloading = false + val language = item.extra[StoreLanguage.EXTRA] ?: StoreLanguage.preferredCode(app) val result = try { GogDownloadManager.install(app, game, folder, object : GogDownloadManager.Callback { override fun onProgress(message: String, pct: Int) { @@ -100,7 +111,7 @@ object GogBackend : StoreBackend { handle.stage(when (stage) { "check" -> DownloadStage.MANIFEST; "verify" -> DownloadStage.VERIFY; else -> DownloadStage.INSTALL }) handle.stageProgress(done, total, items, itemsTotal, bytes = stage == "install") } - }, cancelled) + }, cancelled, language) } catch (t: Throwable) { if (t is GogDownloadManager.InstallerException && !cancelled.get()) { StoreInstalls.discard(app, folder, listOf(File(folder, ".gog_chunks"))) @@ -109,12 +120,14 @@ object GogBackend : StoreBackend { } ?: return null if (cancelled.get()) return null handle.stage(DownloadStage.INSTALL, app.getString(com.droiddeck.launcher.R.string.stores_registering)) + val installedLanguage = result.language?.takeIf { it.isNotEmpty() } ?: language val sidecar = StoreGameSidecar( Store.GOG, game.gameId, game.title, exe = result.exeRelative.ifEmpty { "" }, installVersion = result.buildId, installedAt = System.currentTimeMillis(), cover = item.tallImageUrl ?: item.imageUrl, hero = item.imageUrl, extra = mapOf(com.droiddeck.launcher.frontend.WinCompSources.GOG_DEPENDENCIES to result.dependencies.joinToString(",")) - + (if (result.dependenciesRead) mapOf(com.droiddeck.launcher.frontend.WinCompSources.LIST_READ to "1") else emptyMap()), + + (if (result.dependenciesRead) mapOf(com.droiddeck.launcher.frontend.WinCompSources.LIST_READ to "1") else emptyMap()) + + mapOf(StoreLanguage.EXTRA to installedLanguage), ) if (sidecar.exe.isEmpty()) handle.log("gog: no exe found in ${folder.name}; pick one in Steam settings › Added games") StoreInstalls.complete(app, folder, onStep = { done, steps -> handle.stageProgress(done.toLong(), steps.toLong()) }, sidecar = if (sidecar.exe.isEmpty()) sidecar.copy(exe = "game.exe") else sidecar) diff --git a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogDownloadManager.java b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogDownloadManager.java index e5e1bec684..dae63e5a29 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogDownloadManager.java +++ b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogDownloadManager.java @@ -5,6 +5,7 @@ import android.util.Log; import com.droiddeck.launcher.frontend.AddedGames; import com.droiddeck.launcher.runtime.GuestCommand; +import com.droiddeck.launcher.stores.StoreLanguage; import com.droiddeck.launcher.stores.StoreLog; import com.droiddeck.launcher.stores.download.StoreDownloadTier; @@ -61,6 +62,8 @@ public final class GogDownloadManager { public final long bytes; public List dependencies = new ArrayList<>(); public boolean dependenciesRead = false; + /** Language actually written, after the manifest's depot list resolved the request. Null for builds that have no language depots. */ + public String language; Result(String exeRelative, String buildId, long bytes) { this.exeRelative = exeRelative; this.buildId = buildId; this.bytes = bytes; } } @@ -76,17 +79,23 @@ public final class GogDownloadManager { private GogDownloadManager() {} public static Result install(Context ctx, GogGame game, File installPath, Callback cb, AtomicBoolean cancelled) throws InstallException { + return install(ctx, game, installPath, cb, cancelled, null); + } + + public static Result install(Context ctx, GogGame game, File installPath, Callback cb, AtomicBoolean cancelled, String language) throws InstallException { cb.onProgress("Checking sign-in…", 0); String token = GogAuth.validToken(ctx); if (token == null) throw new InstallException("Not signed in to GOG"); if (cancelled.get()) return null; + String lang = (language == null || language.isEmpty()) ? StoreLanguage.preferredCode(ctx) : language; + cb.onLog("gog: installing language " + lang); cb.onProgress("Fetching builds…", 2); String buildsUrl = "https://content-system.gog.com/products/" + game.gameId + "/os/windows/builds?generation=2"; String buildsJson = httpGet(buildsUrl, null); if (buildsJson == null) buildsJson = httpGet(buildsUrl, token); if (buildsJson != null) { - Gen2Outcome out = runGen2(ctx, game, token, buildsJson, installPath, cb, cancelled); + Gen2Outcome out = runGen2(ctx, game, token, buildsJson, installPath, cb, cancelled, lang); if (out.result != null || cancelled.get()) return out.result; if (out.hardStop) throw new InstallException(out.error); cb.onLog("gen2 unavailable: " + out.error); @@ -109,7 +118,7 @@ public final class GogDownloadManager { Result result; String error; boolean hardStop; } - private static Gen2Outcome runGen2(Context ctx, GogGame game, String token, String buildsJson, File installPath, Callback cb, AtomicBoolean cancelled) { + private static Gen2Outcome runGen2(Context ctx, GogGame game, String token, String buildsJson, File installPath, Callback cb, AtomicBoolean cancelled, String language) { Gen2Outcome out = new Gen2Outcome(); try { cb.onProgress("Fetching manifest…", 5); @@ -136,12 +145,21 @@ public final class GogDownloadManager { cb.onProgress("Reading depot manifests…", 10); List files = new ArrayList<>(); List depotJsons = new ArrayList<>(); + JSONArray owned = new JSONArray(); + List ownedDepots = new ArrayList<>(); for (int i = 0; i < depots.length(); i++) { - if (cancelled.get()) return out; JSONObject depot = depots.getJSONObject(i); String depotPid = depot.optString("productId", ""); if (!depotPid.isEmpty() && !depotPid.equals(baseProductId)) continue; - if (!languageCompatible(depot)) continue; + owned.put(depot); + ownedDepots.add(depot); + } + String resolved = StoreLanguage.pick(StoreLanguage.codesFromDepots(owned), language); + cb.onLog("gog: language " + resolved); + for (int i = 0; i < ownedDepots.size(); i++) { + if (cancelled.get()) return out; + JSONObject depot = ownedDepots.get(i); + if (!depotSelected(depot, resolved)) continue; String manifestHash = depot.optString("manifest"); if (manifestHash == null || manifestHash.isEmpty()) continue; byte[] dmRaw = fetchBytes("https://gog-cdn-fastly.gog.com/content-system/v2/meta/" + buildCdnPath(manifestHash), null); @@ -241,6 +259,7 @@ public final class GogDownloadManager { out.result = new Result(pickExe(installPath, tempExe, game.title), gm.buildId, planned); out.result.dependencies = dependencies; out.result.dependenciesRead = true; + out.result.language = resolved; return out; } catch (Exception e) { out.error = "exception: " + e.getClass().getSimpleName() + (e.getMessage() != null ? ": " + e.getMessage() : ""); @@ -279,11 +298,31 @@ public final class GogDownloadManager { } } - private static boolean languageCompatible(JSONObject depot) { + private static boolean depotSelected(JSONObject depot, String resolved) { JSONArray languages = depot.optJSONArray("languages"); if (languages == null || languages.length() == 0) return true; - String s = languages.toString(); - return s.contains("*") || s.contains("en-US") || s.contains("\"en\"") || s.contains("english"); + String[] listed = new String[languages.length()]; + for (int i = 0; i < languages.length(); i++) listed[i] = languages.optString(i, ""); + return StoreLanguage.depotMatchesResolved(listed, resolved); + } + + /** Language codes listed on this product's Windows gen2 depots, excluding `*`. */ + public static List listLanguages(Context ctx, String gameId) { + try { + String token = GogAuth.validToken(ctx); + String buildsUrl = "https://content-system.gog.com/products/" + gameId + "/os/windows/builds?generation=2"; + String buildsJson = httpGet(buildsUrl, null); + if (buildsJson == null) buildsJson = httpGet(buildsUrl, token); + if (buildsJson == null) return Collections.emptyList(); + Callback silent = new Callback() { + @Override public void onProgress(String message, int pct) {} + }; + Gen2Manifest gm = resolveGen2Manifest(buildsJson, token, silent); + if (gm == null) return Collections.emptyList(); + return StoreLanguage.codesFromDepots(gm.manifest.optJSONArray("depots")); + } catch (Exception e) { + return Collections.emptyList(); + } } @@ -1158,9 +1197,10 @@ public final class GogDownloadManager { JSONArray depots = new JSONObject(manifestStr).optJSONArray("depots"); if (depots == null) return -1; long total = 0; + String resolved = StoreLanguage.pick(StoreLanguage.codesFromDepots(depots), StoreLanguage.preferredCode()); for (int i = 0; i < depots.length(); i++) { JSONObject depot = depots.getJSONObject(i); - if (languageCompatible(depot)) total += depot.optLong("size", 0); + if (depotSelected(depot, resolved)) total += depot.optLong("size", 0); } return total > 0 ? total : -1; } catch (Exception e) { diff --git a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogLibrary.kt b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogLibrary.kt index 61fae1a40f..0e76d2fab2 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogLibrary.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogLibrary.kt @@ -7,6 +7,7 @@ import com.droiddeck.launcher.R import com.droiddeck.launcher.stores.CatalogItem import com.droiddeck.launcher.stores.Store import com.droiddeck.launcher.stores.StoreNet +import com.droiddeck.launcher.stores.StoresState import com.droiddeck.launcher.stores.cleanStoreText import org.json.JSONArray import org.json.JSONObject @@ -20,6 +21,14 @@ object GogLibrary { private const val LAST_SYNC_KEY = "library_synced_at" private const val SKIPPED_KEY = "library_skipped" private const val THROTTLE_MS = 6L * 60L * 60L * 1000L + // mediaType=1 leaves the movies and soundtracks out, hiddenFlag=0 the hidden ones. + private const val LIST_URL = "https://embed.gog.com/account/getFilteredProducts?mediaType=1&hiddenFlag=0&sortBy=title" + private const val LIST_MAX_PAGES = 100 + // The listing's image is a bare hash, and the CDN serves it only through Galaxy's own formatters: the + // vertical cover is the one card art it carries. The wide background only the per-game fetch knows. + private const val COVER_SUFFIX = "_glx_vertical_cover.webp" + // The older account endpoint: owned ids only. The fallback for a listing that cannot be read. + private const val OWNED_URL = "https://embed.gog.com/user/data/games" private val syncing = AtomicBoolean(false) @@ -45,42 +54,44 @@ object GogLibrary { fun sizeOf(context: Context, gameId: String): Long = GogPrefs.get(context).getLong("size_$gameId", 0L) - fun sync(context: Context, force: Boolean = false, onStatus: (String) -> Unit = {}): SyncResult { + fun sync(context: Context, force: Boolean = false, onStatus: (String) -> Unit = {}, onList: (List) -> Unit = {}, onItems: (List) -> Unit = {}): SyncResult { if (!syncing.compareAndSet(false, true)) return SyncResult.Busy try { val app = context.applicationContext val p = GogPrefs.get(app) val token = GogAuth.validToken(app) ?: return SyncResult.NotLoggedIn onStatus(app.getString(R.string.stores_sync_game_list)) - val gamesJson = StoreNet.get("https://embed.gog.com/user/data/games", bearer = token, userAgent = GogAuth.GALAXY_UA) + val listing = ownedListing(token) + // The listing is the only source of titles: without it the owned ids still sync, just without the early paint. + val listed: List = listing?.games + ?: ownedIds(token)?.map { GogGame(it, "", "", "", "", "", 1, null, "", "") } ?: return SyncResult.Failed(app.getString(R.string.stores_sync_gog_unreachable)) - val ids = ArrayList() - val parsed = runCatching { - val owned = JSONObject(gamesJson).optJSONArray("owned") - if (owned != null) for (i in 0 until owned.length()) { - val id = owned.optLong(i).toString() - if (id != "1801418160" && id != "0") ids.add(id) - } - }.isSuccess - if (!parsed) return SyncResult.Failed(app.getString(R.string.stores_sync_gog_unreadable)) - - val ownedSet = ids.toHashSet() + val named = listing != null + StoresState.logLine(if (named) "GOG: listing ${listed.size} games" else "GOG: listing unreadable, ${listed.size} owned ids") + // A page that failed leaves games unnamed: they are still owned, so their cards and cached details stay. + val ownedSet = listing?.owned ?: listed.mapTo(HashSet()) { it.gameId } val cachedList = cached(app) val stale = System.currentTimeMillis() - p.getLong(LAST_SYNC_KEY, 0L) >= THROTTLE_MS val heavy = force || cachedList.isEmpty() || stale val cachedIds = cachedList.mapTo(HashSet()) { it.gameId } + // A product the last sync found uninstallable stays out of the list while it is re-checked. val skipped = java.util.Collections.newSetFromMap(java.util.concurrent.ConcurrentHashMap()) - if (!heavy) skipped.addAll(p.getStringSet(SKIPPED_KEY, emptySet()).orEmpty()) - val idsToFetch = if (heavy) ids else ids.filter { it !in cachedIds && it !in skipped } - val fetchSet = idsToFetch.toHashSet() + skipped.addAll(p.getStringSet(SKIPPED_KEY, emptySet()).orEmpty()) + val idsToFetch = if (heavy) ownedSet.toList() else ownedSet.filter { it !in cachedIds && it !in skipped } val merged = LinkedHashMap() - for (g in cachedList) if (g.gameId in ownedSet && g.gameId !in fetchSet) merged[g.gameId] = g + // The cache's own entry stays even when the game is re-fetched: its details beat the listing's. + for (g in cachedList) if (g.gameId in ownedSet && g.gameId !in skipped) merged[g.gameId] = g + // A game the sync has not reached keeps the listing's entry, so its card is there from the start. + for (g in listed) if (g.gameId !in merged && g.gameId !in skipped) merged[g.gameId] = g + // Only products that were asked about are cached: a bare listing entry is asked about again. + val detailed = HashSet(cachedIds) + if (named) onList(sorted(merged)) if (idsToFetch.isEmpty()) { val list = merged.values.toList() skipped.retainAll(ownedSet) p.edit().putStringSet(SKIPPED_KEY, HashSet(skipped)).apply() - saveCache(p, list) - return SyncResult.Ok(list.sortedBy { it.title.lowercase() }, 0) + saveCache(p, list.filter { it.gameId in detailed }) + return SyncResult.Ok(sorted(merged), 0) } onStatus(app.resources.getQuantityString(R.plurals.stores_sync_games, idsToFetch.size, idsToFetch.size)) val pool = Executors.newFixedThreadPool(5) @@ -89,16 +100,24 @@ object GogLibrary { var fetched = 0 for ((idx, f) in futures.withIndex()) { val g = runCatching { f.get() }.getOrNull() - if (g != null) { merged[g.gameId] = g; fetched++ } + if (g != null) { + // The cover the card already shows stays, so the wide art lands over it instead of over a gap. + val filled = g.withCover(merged[g.gameId]?.verticalCover) + merged[g.gameId] = filled; detailed.add(g.gameId); fetched++; skipped.remove(g.gameId); onItems(listOf(filled)) + } if ((idx + 1) % 5 == 0) onStatus(app.getString(R.string.stores_sync_progress, idx + 1, futures.size)) + // Saved as it goes: a sync the user closes the app on still leaves a library to paint next launch. + if ((idx + 1) % 20 == 0) saveCache(p, merged.values.filter { it.gameId in detailed }) } + // A product this round found uninstallable leaves when the round is over, not in the middle of it. + for (id in skipped) merged.remove(id) val finalList = merged.values.toList() - saveCache(p, finalList) + saveCache(p, finalList.filter { it.gameId in detailed }) skipped.retainAll(ownedSet) p.edit().putStringSet(SKIPPED_KEY, HashSet(skipped)).apply() if (heavy) p.edit().putLong(LAST_SYNC_KEY, System.currentTimeMillis()).apply() - Log.i(TAG, "sync: owned=${ids.size} fetched=$fetched cached=${finalList.size} heavy=$heavy") - return SyncResult.Ok(finalList.sortedBy { it.title.lowercase() }, fetched) + Log.i(TAG, "sync: owned=${ownedSet.size} fetched=$fetched cached=${finalList.size} heavy=$heavy") + return SyncResult.Ok(sorted(merged), fetched) } catch (e: Exception) { Log.w(TAG, "sync failed: ${e.message}") return SyncResult.Failed(e.message ?: context.getString(R.string.stores_sync_failed)) @@ -107,6 +126,68 @@ object GogLibrary { } } + private fun ownedListing(token: String): Listing? { + val all = ArrayList() + val owned = HashSet() + var page = 1 + var pages = 1 + while (page <= pages && page <= LIST_MAX_PAGES) { + // A page that cannot be read ends the listing; the pages already read still name most of the library. + val listed = StoreNet.get("$LIST_URL&page=$page", bearer = token, userAgent = GogAuth.GALAXY_UA)?.let { parseListing(it) } + if (listed == null) { + StoresState.logLine("GOG: listing page $page of $pages unreadable") + // The unread pages hold games too: without their ids those games would leave the library and the cache. + owned.addAll(ownedIds(token) ?: return null) + break + } + all.addAll(listed.games) + owned.addAll(listed.games.map { it.gameId }) + pages = listed.totalPages + page++ + } + // Not one page read: the caller falls back to the owned ids. + return all.ifEmpty { null }?.let { Listing(it, owned) } + } + + private fun ownedIds(token: String): List? { + val json = StoreNet.get(OWNED_URL, bearer = token, userAgent = GogAuth.GALAXY_UA) ?: return null + val owned = runCatching { JSONObject(json).optJSONArray("owned") }.getOrNull() ?: return null + val ids = ArrayList(owned.length()) + for (i in 0 until owned.length()) { + val id = owned.optLong(i).toString() + if (id != "1801418160" && id != "0") ids.add(id) + } + return ids + } + + fun parseListing(json: String): ListingPage? = runCatching { + val root = JSONObject(json) + val arr = root.optJSONArray("products") ?: return@runCatching null + val games = ArrayList(arr.length()) + for (i in 0 until arr.length()) { + val o = arr.optJSONObject(i) ?: continue + // 1801418160 is GOG's own "Galaxy" entry, in every library. + val id = o.optLong("id", 0L).toString() + if (id == "0" || id == "1801418160") continue + if (o.optBoolean("isMovie", false) || !o.optBoolean("isGame", true)) continue + val title = o.optString("title", "").trim() + if (title.isEmpty()) continue + val worksOn = o.optJSONObject("worksOn") + if (worksOn != null && !worksOn.optBoolean("Windows", true)) continue + val released = o.optJSONObject("releaseDate")?.optString("date", "").orEmpty().substringBefore(' ') + val image = o.optString("image", "").ifBlank { null } + games.add(GogGame(id, title, "", "", "", o.optString("category", ""), 1, + image?.let { GogStoreCatalog.absolutize(it + COVER_SUFFIX) }, released, "")) + } + ListingPage(games, maxOf(1, root.optInt("totalPages", 1))) + }.getOrNull() + + class ListingPage(val games: List, val totalPages: Int) + + private class Listing(val games: List, val owned: Set) + + private fun sorted(merged: Map): List = merged.values.sortedBy { it.title.lowercase() } + private fun fetchGame(prefs: SharedPreferences, id: String, token: String, skipped: MutableSet): GogGame? { fun skip(): GogGame? { skipped.add(id); return null } try { @@ -198,6 +279,10 @@ object GogLibrary { } } + private fun GogGame.withCover(cover: String?): GogGame = + if (cover.isNullOrBlank() || cover == verticalCover) this + else GogGame(gameId, title, imageUrl, description, developer, category, generation, cover, releaseDate, publisher) + fun toCatalogItem(context: Context, g: GogGame): CatalogItem = CatalogItem( store = Store.GOG, id = g.gameId, title = g.title, imageUrl = GogStoreCatalog.absolutize(g.imageUrl).ifBlank { null }, diff --git a/app/src/main/java/com/droiddeck/launcher/stores/xbox/XboxCatalog.kt b/app/src/main/java/com/droiddeck/launcher/stores/xbox/XboxCatalog.kt index fa7a6b5faa..100371b06e 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/xbox/XboxCatalog.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/xbox/XboxCatalog.kt @@ -10,6 +10,14 @@ import java.time.Instant internal object XboxCatalog { private val productId = Regex("[A-Z0-9]{12}") private val plans = setOf("CFQ7TTC0KGQ8", "CFQ7TTC0KHS0", "CFQ7TTC0P85B", "CFQ7TTC0K5DJ", "CFQ7TTC0K6L8", "CFQ7TTC10QFD") + /** Plans that include PC games; the retired console-only plan must not offer a Windows install. */ + private val pcPlans = mapOf( + "CFQ7TTC0KGQ8" to "PC Game Pass", + "CFQ7TTC0KHS0" to "Game Pass Ultimate", + "CFQ7TTC0P85B" to "Xbox Game Pass Premium", + "CFQ7TTC0K5DJ" to "Xbox Game Pass Essential", + "CFQ7TTC10QFD" to "Xbox Game Pass (Starter Edition)", + ) fun access(json: JSONObject, account: String, market: String, now: Instant = Instant.now(), report: (String) -> Unit = {}): Map { require(json.getInt("schema") == 1 && json.getString("account") == account && json.getString("market") == market) @@ -53,7 +61,7 @@ internal object XboxCatalog { val parent = row.optString("satisfiedByProductId").takeUnless { it.isBlank() || it == "null" } if (parent == null) return if (id in plans) null else "owned" if (parent in blocked) return null - if (parent in plans) return if (activePlan(parent)) "gamepass" else null + if (parent in plans) return if (parent in pcPlans && activePlan(parent)) "gamepass" else null return kind(parent, visited + id) } val result = rows.keys.mapNotNull { id -> kind(id)?.let { id to it } }.toMap() @@ -110,9 +118,12 @@ internal object XboxCatalog { } } val kind = access[id] + val includedWith = objects(localized.optJSONObject("EligibilityProperties")?.optJSONArray("Affirmations")) + .mapNotNull { pcPlans[it.optString("AffirmationProductId")] } + .firstOrNull().orEmpty() return CatalogItem(Store.XBOX, id, title, image("SuperHeroArt", "Hero", "BoxArt"), tallImageUrl = image("TitledPoster", "Poster", "BoxArt"), - owned = kind == "owned", subscription = kind == "gamepass", + owned = kind == "owned", subscription = kind == "gamepass", includedWith = includedWith, storeUrl = "https://www.xbox.com/games/store/$id", publisher = localized.optString("PublisherName"), developer = localized.optString("DeveloperName"), description = localized.optString("ProductDescription"), diff --git a/app/src/main/java/com/droiddeck/launcher/stores/xbox/Xodus.kt b/app/src/main/java/com/droiddeck/launcher/stores/xbox/Xodus.kt index 8eb237d02c..6e7c30df84 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/xbox/Xodus.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/xbox/Xodus.kt @@ -3,6 +3,7 @@ package com.droiddeck.launcher.stores.xbox import android.content.Context import android.os.Environment import com.droiddeck.launcher.core.AddonPack +import com.droiddeck.launcher.runtime.LinuxNetworkLinkComponent import com.droiddeck.launcher.runtime.LinuxRuntime import com.droiddeck.launcher.session.SessionPrefs import org.json.JSONObject @@ -14,7 +15,8 @@ internal object Xodus { const val DIR = "/usr/local/lib/droiddeck-xbox" fun market(): String = java.util.Locale.getDefault().country.uppercase().takeIf { it.matches(Regex("[A-Z]{2}")) } ?: "US" - class Child(val process: Process, private val credentials: XboxCredentials, private val runtimeDirectory: File? = null, private val launchDirectory: File? = null) : Closeable { + class Child(val process: Process, private val credentials: XboxCredentials, private val runtimeDirectory: File? = null, private val launchDirectory: File? = null, + private val networkLink: LinuxNetworkLinkComponent) : Closeable { @Synchronized fun send(frame: JSONObject) { process.outputStream.write((frame.toString() + "\n").toByteArray()) process.outputStream.flush() @@ -34,6 +36,7 @@ internal object Xodus { } } } finally { + networkLink.stop() runtimeDirectory?.let { directory -> File(directory, "xodus.sock").delete() directory.delete() @@ -69,8 +72,12 @@ internal object Xodus { val pack = stage(app) val binary = "$DIR/${if (service) "xodus-service" else "xodus-cli"}" check(File(LinuxRuntime.rootDir(app), binary.removePrefix("/")).isFile) { "The Xbox backend is missing. Update the Linux runtime." } + val networkLink = LinuxNetworkLinkComponent(app, LinuxRuntime.rootDir(app)) val credentials = XboxCredentials(app, credentialGeneration) try { + networkLink.attach(app) + networkLink.publish() + networkLink.start() val runtime = (runtimeDirectory ?: File(app.filesDir, "xbox-runtime")).apply { mkdirs() } val command = LinuxRuntime.command(app, null, null, Environment.getExternalStorageDirectory(), listOf( "/usr/bin/env", "HOME=/root", "XODUS_LOG=off", "RUST_LOG=off", @@ -92,8 +99,12 @@ internal object Xodus { } val process = builder.start() credentials.bind(process, File(LinuxRuntime.rootDir(app), binary.removePrefix("/")), digest.digest()) - return Child(process, credentials, runtimeDirectory, launchDirectory) - } catch (e: Exception) { credentials.close(); throw e } + return Child(process, credentials, runtimeDirectory, launchDirectory, networkLink) + } catch (e: Exception) { + runCatching { networkLink.stop() } + credentials.close() + throw e + } } fun run(app: Context, args: List, timeout: Long = 90, credentialGeneration: String? = null): JSONObject { diff --git a/app/src/main/java/com/droiddeck/launcher/ui/AddAppDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/AddAppDialog.kt index ccd7fd05e3..bee26dd0dc 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/AddAppDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/AddAppDialog.kt @@ -315,7 +315,7 @@ internal fun AppDialog( Box( contentAlignment = Alignment.Center, modifier = Modifier.fillMaxSize().imePadding() - .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null, onClick = close), + .tapOutside(close), ) { AnimatedVisibility( visibleState = shown, @@ -340,7 +340,7 @@ internal fun AppDialog( .clip(Shape16) .background(pal.surfaceVariant.copy(alpha = 0.97f)) .border(1.dp, pal.signal.copy(alpha = 0.22f), Shape16) - .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null) {} + .blockTouches() .controllerBack(back ?: close) .then(modifier) .then(if (scrollable) Modifier.verticalScroll(rememberScrollState()) else Modifier) diff --git a/app/src/main/java/com/droiddeck/launcher/ui/AddedGameEditor.kt b/app/src/main/java/com/droiddeck/launcher/ui/AddedGameEditor.kt index cec6c7a426..3d86510f70 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/AddedGameEditor.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/AddedGameEditor.kt @@ -40,6 +40,12 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusRequester +import androidx.compose.foundation.gestures.detectTapGestures +import androidx.compose.ui.input.pointer.pointerInput +import androidx.compose.ui.platform.LocalSoftwareKeyboardController +import androidx.compose.ui.platform.LocalFocusManager +import androidx.compose.ui.platform.LocalInputModeManager +import androidx.compose.ui.input.InputMode import androidx.compose.ui.layout.ContentScale import androidx.compose.ui.platform.LocalConfiguration import android.content.Context @@ -502,7 +508,7 @@ private fun ArtChooserDialog( sgdb = found?.sgdb ?: SteamGridDb.Status.SERVER } val first = remember { FocusRequester() } - LaunchedEffect(Unit) { focusWithinFrames({ false }) { first } } + LaunchedEffect(options != null) { focusWithinFrames({ false }) { first } } val apply: (AddedGameArt.Option) -> Unit = { option -> scope.launch { val saved = withContext(Dispatchers.IO) { target.set(app, slot, option) } @@ -624,14 +630,23 @@ private fun SgdbSearchDialog( } } LaunchedEffect(Unit) { search() } - AppDialog(shown, back, "sgdbSearch", wide = false, maxWidth = 460.dp) { + val firstItem = remember { FocusRequester() } + val focusManager = LocalFocusManager.current + val keyboardController = LocalSoftwareKeyboardController.current + val leaveField = { focusManager.clearFocus(); keyboardController?.hide() } + val keyboard = LocalInputModeManager.current.inputMode == InputMode.Keyboard + LaunchedEffect(picked?.id, matches?.size, images.size, busy) { + val ready = if (picked != null) images.isNotEmpty() else !matches.isNullOrEmpty() + if (keyboard && !busy && ready) focusSoon { firstItem } + } + AppDialog(shown, back, "sgdbSearch", wide = false, maxWidth = 460.dp, modifier = Modifier.pointerInput(Unit) { detectTapGestures { leaveField() } }) { DialogTitleRow(stringResource(R.string.art_sgdb_title, slotName), onClose = { onCloseAll() }, leading = { SmallIconButton(Icons.AutoMirrored.Filled.ArrowBack, stringResource(R.string.common_back), colors.onBackground, onClick = back) }) androidx.compose.material3.OutlinedTextField( query, { query = it }, singleLine = true, modifier = Modifier.fillMaxWidth(), label = { Text(stringResource(R.string.art_sgdb_search_label)) }, - keyboardActions = androidx.compose.foundation.text.KeyboardActions(onSearch = { search() }), + keyboardActions = androidx.compose.foundation.text.KeyboardActions(onSearch = { leaveField(); search() }), keyboardOptions = androidx.compose.foundation.text.KeyboardOptions(imeAction = androidx.compose.ui.text.input.ImeAction.Search), ) val maxHeight = (LocalConfiguration.current.screenHeightDp * 0.6f).dp @@ -643,24 +658,24 @@ private fun SgdbSearchDialog( val chosenGame = picked val list = matches.orEmpty() if (chosenGame == null) { - for (match in list) key(match.id) { PickerRow(null, match.name, null) { showImages(match) } } + list.forEachIndexed { i, match -> key(match.id) { PickerRow(null, match.name, null, focus = if (i == 0) firstItem else null) { leaveField(); showImages(match) } } } if (matches != null && list.isEmpty() && !busy && status == SteamGridDb.Status.OK) { Text(stringResource(R.string.art_sgdb_none), fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(start = 2.dp, top = 4.dp)) } } else { Text(chosenGame.name, fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(start = 2.dp, top = 4.dp)) FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { - for (option in images) key(option.full) { + images.forEachIndexed { i, option -> key(option.full) { ArtOption( - slot, option, selected = current?.chosen == true && option.full == chosenRef, focus = null, + slot, option, selected = current?.chosen == true && option.full == chosenRef, focus = if (i == 0) firstItem else null, description = "${artSourceLabel(AddedGameArt.SGDB)} $slotName", ) { onPick(option) } - } + } } } if (images.isEmpty() && !busy && status == SteamGridDb.Status.OK) { Text(stringResource(R.string.art_sgdb_none), fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(start = 2.dp, top = 4.dp)) } - if (list.size > 1) PickerRow(null, stringResource(R.string.art_sgdb_other_games), null) { picked = null } + if (list.size > 1) PickerRow(null, stringResource(R.string.art_sgdb_other_games), null) { leaveField(); picked = null } } if (busy) androidx.compose.material3.LinearProgressIndicator(Modifier.fillMaxWidth().padding(vertical = 8.dp)) } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/BootMovieSection.kt b/app/src/main/java/com/droiddeck/launcher/ui/BootMovieSection.kt index 3878d274b6..a4227d4c28 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/BootMovieSection.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/BootMovieSection.kt @@ -69,6 +69,7 @@ import androidx.compose.runtime.DisposableEffect import androidx.compose.runtime.mutableFloatStateOf import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusRequester +import androidx.compose.ui.focus.onFocusChanged import androidx.compose.ui.input.InputMode import androidx.compose.ui.platform.LocalConfiguration import androidx.compose.ui.platform.LocalInputModeManager @@ -558,13 +559,37 @@ private fun repoInfo(post: SteamDeckRepo.Post): String = listOf(post.author, "♥ ${post.likes}", "⇩ ${post.downloads}", if (post.seconds > 0) stringResource(R.string.boot_movie_seconds, post.seconds) else "") .filter { it.isNotEmpty() }.joinToString(" · ") +private const val AFTER_OPEN = 3 +private const val AFTER_INSTALL = 1 +private const val AFTER_USE = 2 + +/** Install and Use are different buttons in turn, and the button is disabled while installing; it takes focus back for the controller. */ @Composable -private fun RepoAction(installed: Boolean, inUse: Boolean, percent: Int?, busy: Boolean, modifier: Modifier, onInstall: () -> Unit, onUse: () -> Unit) { - if (inUse) SecondaryButton(stringResource(R.string.boot_movie_in_use), compact = true, modifier = modifier, onClick = {}) - else if (installed) SecondaryButton(stringResource(R.string.boot_movie_repo_use), compact = true, modifier = modifier, onClick = onUse) +private fun RepoAction( + installed: Boolean, inUse: Boolean, percent: Int?, busy: Boolean, modifier: Modifier, onInstall: () -> Unit, onUse: () -> Unit, + takeFocus: Boolean = false, +) { + val requester = remember { FocusRequester() } + val focused = remember { booleanArrayOf(false) } + var pending by remember { mutableIntStateOf(if (takeFocus) AFTER_OPEN else 0) } + val inputMode = LocalInputModeManager.current + LaunchedEffect(installed, inUse, busy, percent != null, pending) { + if (pending == 0) return@LaunchedEffect + if (inputMode.inputMode != InputMode.Keyboard) { pending = 0; return@LaunchedEffect } + focusWithinFrames({ focused[0] }) { requester } + when (pending) { + AFTER_OPEN -> pending = 0 + AFTER_INSTALL -> if (installed && focused[0]) pending = 0 + AFTER_USE -> if (inUse && focused[0]) pending = 0 + else -> Unit + } + } + val m = modifier.focusRequester(requester).onFocusChanged { focused[0] = it.hasFocus || it.isFocused } + if (inUse) SecondaryButton(stringResource(R.string.boot_movie_in_use), compact = true, modifier = m, onClick = {}) + else if (installed) SecondaryButton(stringResource(R.string.boot_movie_repo_use), compact = true, modifier = m, onClick = { pending = AFTER_USE; onUse() }) else SecondaryButton( if (percent != null) stringResource(R.string.boot_movie_converting, percent) else stringResource(R.string.boot_movie_repo_install), - enabled = !busy, compact = true, modifier = modifier, onClick = onInstall, + enabled = !busy, compact = true, modifier = m, onClick = { pending = AFTER_INSTALL; onInstall() }, ) } @@ -576,9 +601,6 @@ private fun PreviewDialog( ) { val shown = rememberShown(onDismiss) val close = { shown.targetState = false } - val action = remember { FocusRequester() } - val inputMode = LocalInputModeManager.current - LaunchedEffect(Unit) { if (inputMode.inputMode == InputMode.Keyboard) focusSoon { action } } val maxVideoHeight = (LocalConfiguration.current.screenHeightDp - 200).coerceAtLeast(120).dp AppDialog(shown, close, "boot-movie-preview", wide = false, maxWidth = 620.dp) { DialogTitleRow(post.title, close) @@ -586,7 +608,7 @@ private fun PreviewDialog( MoviePreview(post.video, Modifier.heightIn(max = maxVideoHeight).aspectRatio(16f / 9f)) } Text(repoInfo(post), fontSize = 12.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis) - RepoAction(installed, inUse, percent, busy, Modifier.fillMaxWidth().focusRequester(action), onInstall, onUse) + RepoAction(installed, inUse, percent, busy, Modifier.fillMaxWidth(), onInstall, onUse, takeFocus = true) } } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ComponentsPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/ComponentsPage.kt index d44f599406..e3de1f325e 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/ComponentsPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/ComponentsPage.kt @@ -30,6 +30,7 @@ import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.width import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.selection.toggleable import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.foundation.verticalScroll @@ -73,6 +74,8 @@ import androidx.compose.ui.platform.LocalDensity import androidx.compose.ui.platform.LocalInputModeManager import androidx.compose.ui.res.stringResource import androidx.compose.ui.semantics.Role +import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.semantics.stateDescription import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp @@ -381,6 +384,7 @@ fun ComponentsPage( var stackAt by remember { mutableStateOf(Offset.Zero) } var pageAt by remember { mutableStateOf(Offset.Zero) } val landed = remember { mutableStateMapOf() } + val nightlyPicked = remember { mutableStateMapOf() } val rings = remember { mutableStateMapOf() } fun land(l: String) { landed[l] = (landed[l] ?: 0) + 1; rings[l] = (rings[l] ?: 0) + 1 } val arrivedSeen = remember { intArrayOf(Hops.arrived) } @@ -504,7 +508,7 @@ fun ComponentsPage( val availableTitle: @Composable (String) -> String = { l -> when (l) { PROTON_TAB -> stringResource(R.string.comp_available_count, protons.rows.count { it.installed == null || it.update != null }) - else -> stringResource(R.string.comp_nightlies_count, availableFor(l, catalog, snapshot).size) + else -> stringResource(R.string.comp_nightlies_count, availableRows(l, catalog, snapshot).size) } } val installedRows: @Composable ColumnScope.(String, Boolean) -> Unit = { l, right -> @@ -581,12 +585,16 @@ fun ComponentsPage( ) { protonActions.onInstall(row.id) } } else -> { - val available = availableFor(l, catalog, snapshot) + val available = availableRows(l, catalog, snapshot) if (available.isEmpty()) EmptyLine(if (catalogAt == 0L) stringResource(R.string.comp_refresh_to_list) else stringResource(R.string.comp_nothing_new)) - for (d in available) GetLine( - d.file.removeSuffix(".wcp"), "${d.release} · " + stringResource(R.string.common_size_mb, d.size / 1048576.0), - progress = downloads[d.file], enabled = busy == null, - ) { onDownload(d) } + for ((stable, nightly) in available) { + val d = if (nightly != null && nightlyPicked[stable.file] == true) nightly else stable + GetLine( + d.file.removeSuffix(".wcp"), "${d.release} · " + stringResource(R.string.common_size_mb, d.size / 1048576.0), + progress = downloads[d.file], enabled = busy == null, + channel = if (nightly != null) ({ ChannelToggle(d === nightly, enabled = busy == null) { nightlyPicked[stable.file] = d !== nightly } }) else null, + ) { onDownload(d) } + } } } } @@ -922,6 +930,14 @@ private fun availableFor(l: String, catalog: List, snapshot: Snapsh return catalog.filter { it.comp == l && ComponentsManager.safeName(it.file) !in stored } } +// The rows to show: each stable row carries its paired nightly (if any), and a paired nightly has no row of its own. +private fun availableRows(l: String, catalog: List, snapshot: Snapshot?): List> { + val available = availableFor(l, catalog, snapshot) + val pairs = ComponentsManager.nightlyPairs(available) + val paired = pairs.values.toSet() + return available.filter { it !in paired }.map { it to pairs[it] } +} + @Composable private fun LayerTitle(l: String): String = when (l) { GPU_TAB -> stringResource(R.string.comp_gpu_drivers) @@ -1417,7 +1433,8 @@ private fun ChoiceLine( @Composable private fun GetLine( name: String, detail: String, progress: Int?, enabled: Boolean, - badge: String? = null, stage: String? = null, onCancel: (() -> Unit)? = null, action: String? = null, onGet: () -> Unit, + badge: String? = null, stage: String? = null, onCancel: (() -> Unit)? = null, action: String? = null, + channel: (@Composable () -> Unit)? = null, onGet: () -> Unit, ) { val colors = MaterialTheme.colorScheme val pal = LocalPalette.current @@ -1432,12 +1449,43 @@ private fun GetLine( if (progress != null) ProgressBit(progress) else { if (onCancel != null) FocusText(stringResource(R.string.proton_cancel_queued), pal.signal, onClick = onCancel) + channel?.invoke() SmallButton(action ?: stringResource(R.string.comp_get), enabled = enabled, accent = true, onClick = onGet) } } Box(Modifier.fillMaxWidth().height(1.dp).background(pal.line)) } +// Stable | Nightly in the same box as SmallButton: one focus stop, A (or a tap) flips it. +@Composable +private fun ChannelToggle(nightly: Boolean, enabled: Boolean, onFlip: () -> Unit) { + val colors = MaterialTheme.colorScheme + val pal = LocalPalette.current + val src = remember { MutableInteractionSource() } + val hot = rememberHot(src) && enabled + val state = stringResource(if (nightly) R.string.comp_channel_nightly else R.string.comp_channel_stable) + Row( + verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(2.dp), + modifier = Modifier.heightIn(min = 44.dp).clip(RoundedCornerShape(10.dp)) + .background(colors.surfaceVariant) + .glideBorder(hot, RoundedCornerShape(10.dp), colors.onBackground, pal.line2, restWidth = 2.dp) + .hoverable(src).toggleable(value = nightly, interactionSource = src, indication = null, enabled = enabled, role = Role.Switch, onValueChange = { onFlip() }) + .controllerConfirm(enabled = enabled, onClick = onFlip) + .semantics { stateDescription = state } + .padding(4.dp), + ) { + for ((label, on) in listOf(R.string.comp_channel_stable to !nightly, R.string.comp_channel_nightly to nightly)) { + Text( + stringResource(label), fontSize = 13.sp, fontWeight = FontWeight.SemiBold, maxLines = 1, + color = if (!enabled) colors.onSurfaceVariant else if (on) (if (hot) pal.onSignal else pal.signal) else colors.onSurfaceVariant, + modifier = Modifier.clip(RoundedCornerShape(7.dp)) + .background(if (on && enabled) (if (hot) pal.signal else pal.signal.copy(alpha = 0.16f)) else Color.Transparent) + .padding(horizontal = 10.dp, vertical = 6.dp), + ) + } + } +} + @Composable private fun DetailLine(detail: String, badge: String?) { val colors = MaterialTheme.colorScheme diff --git a/app/src/main/java/com/droiddeck/launcher/ui/DeckControlsPanel.kt b/app/src/main/java/com/droiddeck/launcher/ui/DeckControlsPanel.kt index b030632fc6..c34d1a9710 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/DeckControlsPanel.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/DeckControlsPanel.kt @@ -17,6 +17,7 @@ import android.view.MotionEvent import android.view.View import android.view.ViewGroup import android.widget.FrameLayout +import android.widget.HorizontalScrollView import android.widget.LinearLayout import android.widget.TextView import com.droiddeck.launcher.input.DeckControls @@ -49,13 +50,6 @@ class DeckControlsPanel( select(if (pad != null) selectedWithPad else selected) } - override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) { - super.onSizeChanged(w, h, oldw, oldh) - if (pad != null && selectedWithPad != Tab.GAMEPAD && !GamepadGeometry.tall(w.toFloat(), h.toFloat())) { - post { if (selectedWithPad != Tab.GAMEPAD) select(Tab.GAMEPAD) } - } - } - override fun onDetachedFromWindow() { DeckControls.releaseAll() super.onDetachedFromWindow() @@ -85,8 +79,10 @@ class DeckControlsPanel( addView(view, LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT)) } } - val centre = FrameLayout(context).apply { - addView(tabs, FrameLayout.LayoutParams(FrameLayout.LayoutParams.WRAP_CONTENT, dp(44), Gravity.CENTER)) + val centre = HorizontalScrollView(context).apply { + isHorizontalScrollBarEnabled = false + overScrollMode = View.OVER_SCROLL_NEVER + addView(tabs, FrameLayout.LayoutParams(FrameLayout.LayoutParams.WRAP_CONTENT, dp(44))) } addView(centre, LayoutParams(0, LayoutParams.MATCH_PARENT, 1f)) addView(roundButton("STEAM", context.getString(R.string.deck_open_steam_menu), onSteamMenu, wide = true)) @@ -102,6 +98,17 @@ class DeckControlsPanel( view.background = if (on) filled(CORNER_PILL, ACCENT) else null view.setTextColor(if (on) ON_ACCENT else TEXT_DIM) } + tabViews[tab]?.let { selectedView -> + (selectedView.parent?.parent as? HorizontalScrollView)?.post { + val left = selectedView.left + val right = selectedView.right + val scroll = selectedView.parent?.parent as? HorizontalScrollView ?: return@post + when { + left < scroll.scrollX -> scroll.smoothScrollTo(left, 0) + right > scroll.scrollX + scroll.width -> scroll.smoothScrollTo(right - scroll.width, 0) + } + } + } content.removeAllViews() topBar.visibility = if (tab == Tab.GAMEPAD) View.GONE else View.VISIBLE content.addView( @@ -643,7 +650,7 @@ class DeckControlsPanel( private const val CLICK_MS = 300L private var selected = Tab.BOTH - private var selectedWithPad = Tab.GAMEPAD + private var selectedWithPad = Tab.BOTH private const val CORNER = 20f private const val CORNER_PILL = 22f diff --git a/app/src/main/java/com/droiddeck/launcher/ui/DesktopPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/DesktopPage.kt index e1068a53cb..f6ce824ea8 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/DesktopPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/DesktopPage.kt @@ -52,6 +52,7 @@ import androidx.compose.runtime.key import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.produceState import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberUpdatedState import androidx.compose.runtime.saveable.rememberSaveable import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment @@ -142,8 +143,13 @@ internal fun DesktopPage(s: FrontEndState, a: FrontEndActions, modifier: Modifie PrimaryButton(open, enabled = !s.busy, main = true, large = true, icon = Icons.Outlined.DesktopWindows, onClick = click) }, beside = { - HeroIconButton(Icons.Outlined.Storefront, stringResource(R.string.flathub_name), FlathubTeal, "desktop:flathub") { at -> openFrom(at, null, "store") } - HeroIconButton(Icons.Filled.Add, stringResource(R.string.user_apps_add), null, "desktop:add") { if (!s.busy) adding = true } + Column(verticalArrangement = Arrangement.spacedBy(10.dp)) { + Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) { + HeroIconButton(Icons.Outlined.Storefront, stringResource(R.string.flathub_name), FlathubTeal, "desktop:flathub") { at -> openFrom(at, null, "store") } + HeroIconButton(Icons.Filled.Add, stringResource(R.string.user_apps_add), null, "desktop:add") { if (!s.busy) adding = true } + } + if (s.desktopPresent) UninstallDesktop(enabled = !s.runtimeActionsBlocked, onUninstall = a.onRemoveDesktop) + } }, rows = { tab -> if (tab == SheetTab.FILES) DesktopFiles(s, a) @@ -366,6 +372,7 @@ private fun DesktopFiles(s: FrontEndState, a: FrontEndActions) { @Composable private fun UninstallDesktop(enabled: Boolean, onUninstall: () -> Unit) { + val canUninstall by rememberUpdatedState(enabled) val colors = MaterialTheme.colorScheme val label = stringResource(R.string.common_uninstall) val title = stringResource(R.string.desktop_uninstall_title) @@ -383,7 +390,7 @@ private fun UninstallDesktop(enabled: Boolean, onUninstall: () -> Unit) { Text(note, fontSize = 13.sp, color = colors.onSurfaceVariant, modifier = Modifier.stepItem(1).padding(start = 4.dp, bottom = 12.dp)) Row(horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.End), modifier = Modifier.fillMaxWidth().stepItem(2)) { StepChoice(keep, enabled = open, modifier = Modifier.focusRequester(first)) { Steps.fold() } - StepChoice(label, danger = true, enabled = open) { Steps.fold(); onUninstall() } + StepChoice(label, danger = true, enabled = open && canUninstall) { Steps.fold(); onUninstall() } } }) } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndGames.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndGames.kt index a6032cd3c5..f86062e241 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndGames.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndGames.kt @@ -268,6 +268,21 @@ private fun ManageSaves(g: Library.SteamGame, prefix: java.io.File, a: FrontEndA } } +/** A skipped sync is not a success: "0 files" used to show for a signed-out store or cloud saves turned off. */ +internal fun cloudMessage(context: android.content.Context, r: com.droiddeck.launcher.stores.CloudSaves.Result): String = when (r.result) { + "ok" -> when { + r.conflicts > 0 -> context.getString(R.string.cloud_conflict_files, r.conflicts) + r.files == 0 -> context.getString(R.string.cloud_up_to_date) + else -> context.getString(R.string.cloud_done, r.files) + } + "skipped" -> context.getString(when (r.reason) { + "not-signed-in" -> R.string.cloud_signed_out + "no-cloud-saves" -> R.string.cloud_none + else -> R.string.cloud_not_synced + }) + else -> context.getString(R.string.cloud_not_synced) +} + @Composable private fun CloudRows(g: Library.SteamGame, open: Boolean, first: androidx.compose.ui.focus.FocusRequester) { val store = com.droiddeck.launcher.stores.Store.byId(g.source)?.takeIf { it != com.droiddeck.launcher.stores.Store.AMAZON } ?: return @@ -290,7 +305,7 @@ private fun CloudRows(g: Library.SteamGame, open: Boolean, first: androidx.compo busy = if (up) "up" else "down" Thread({ val r = if (up) com.droiddeck.launcher.stores.CloudSaves.upload(context, store, id, force) else com.droiddeck.launcher.stores.CloudSaves.download(context, store, id, force) - com.droiddeck.launcher.stores.StoresState.post { busy = null; tick++; android.widget.Toast.makeText(context, if (r.ok) context.getString(R.string.cloud_done, r.files) else r.reason, android.widget.Toast.LENGTH_SHORT).show() } + com.droiddeck.launcher.stores.StoresState.post { busy = null; tick++; android.widget.Toast.makeText(context, cloudMessage(context, r), android.widget.Toast.LENGTH_SHORT).show() } }, "cloud-manual").start() } MenuItem(stringResource(R.string.store_cloud_saves), checked = enabled && supported, enabled = supported, focusRequester = first, @@ -302,7 +317,7 @@ private fun CloudRows(g: Library.SteamGame, open: Boolean, first: androidx.compo com.droiddeck.launcher.stores.StoresState.post { enabled = written?.cloud ?: enabled } }, "cloud-switch").start() } - val ready = st != null && supported && busy == null + val ready = st != null && supported && enabled && busy == null val pending = stringResource(R.string.cloud_pending) val summary = when { st == null || busy != null -> pending diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt index 6e44aca350..1840d0f077 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndScreen.kt @@ -132,7 +132,7 @@ class FrontEndState( val controller: com.droiddeck.launcher.input.ControllerPrefs.Settings? = null, val phantomProcessStatus: PhantomProcessStatus = PhantomProcessStatus.NOT_APPLICABLE, val showPhantomGate: Boolean = false, - val orientation: Int = android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE, + val orientation: Int = android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE, val launcherFullscreen: Boolean = true, val downloadSource: String = DownloadSource.MODE_AUTO, val downloadMirror: String = "", diff --git a/app/src/main/java/com/droiddeck/launcher/ui/GlassesPanel.kt b/app/src/main/java/com/droiddeck/launcher/ui/GlassesPanel.kt index 0d06087307..50ce39b29a 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/GlassesPanel.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/GlassesPanel.kt @@ -79,6 +79,33 @@ internal object GlassesTab { const val VR = "vr" const val HARDWARE = "hardware" const val TRACKING = "tracking" + const val CONTROLLERS = "controllers" +} + +@Composable +internal fun VrControllerGroups(host: MenuHost, track: (String) -> Modifier = { Modifier }) { + val context = androidx.compose.ui.platform.LocalContext.current + androidx.compose.runtime.LaunchedEffect(Unit) { com.droiddeck.launcher.input.VrControllers.load(context) } + val c by com.droiddeck.launcher.input.VrControllers.settings.collectAsState() + val emulate = com.droiddeck.launcher.input.VrControllers.Emulate.entries + SettingsGroup(stringResource(R.string.vr_controllers_group)) { + ChoiceRow(host, "vr-emulate", stringResource(R.string.vr_controllers_emulate), stringResource(R.string.vr_controllers_emulate_hint), + emulate.map { it to stringResource(when (it) { + com.droiddeck.launcher.input.VrControllers.Emulate.OFF -> R.string.vr_controllers_off + com.droiddeck.launcher.input.VrControllers.Emulate.INDEX -> R.string.vr_controllers_index + com.droiddeck.launcher.input.VrControllers.Emulate.TOUCH -> R.string.vr_controllers_touch + com.droiddeck.launcher.input.VrControllers.Emulate.VIVE -> R.string.vr_controllers_vive + }) }, c.emulate, chipModifier = track("vr-emulate")) { com.droiddeck.launcher.input.VrControllers.setEmulate(context, it) } + if (c.emulate != com.droiddeck.launcher.input.VrControllers.Emulate.OFF) ChoiceRow(host, "vr-sticks", + stringResource(R.string.vr_controllers_sticks), stringResource(R.string.vr_controllers_sticks_hint), + listOf(false to stringResource(R.string.vr_controllers_sticks_game), true to stringResource(R.string.vr_controllers_sticks_hands)), + c.sticksMoveHands, chipModifier = track("vr-sticks")) { com.droiddeck.launcher.input.VrControllers.setSticksMoveHands(context, it) } + SettingsRow(stringResource(R.string.vr_controllers_buttons), stringResource(when (c.emulate) { + com.droiddeck.launcher.input.VrControllers.Emulate.OFF -> R.string.vr_controllers_buttons_off + com.droiddeck.launcher.input.VrControllers.Emulate.VIVE -> R.string.vr_controllers_buttons_vive + else -> R.string.vr_controllers_buttons_stick + }), hintLines = 6) {} + } } @Composable @@ -362,13 +389,3 @@ private fun GlassesRecenterAction(label: String, tag: String, tint: Int, opacity } } -@Composable -internal fun GlassesPlayingHint(model: String) { - Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { - Column(horizontalAlignment = Alignment.CenterHorizontally) { - Icon(GlassesIcon, null, tint = Color.White.copy(alpha = 0.35f), modifier = Modifier.size(56.dp)) - Spacer(Modifier.height(10.dp)) - Text(stringResource(R.string.glasses_playing, model), color = Color.White.copy(alpha = 0.45f), fontSize = 15.sp) - } - } -} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/GlassesPhonePanel.kt b/app/src/main/java/com/droiddeck/launcher/ui/GlassesPhonePanel.kt new file mode 100644 index 0000000000..625c30efb8 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/ui/GlassesPhonePanel.kt @@ -0,0 +1,85 @@ +package com.droiddeck.launcher.ui + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.ExperimentalLayoutApi +import androidx.compose.foundation.layout.FlowRow +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.displayCutout +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.widthIn +import androidx.compose.foundation.layout.windowInsetsPadding +import androidx.compose.material3.Icon +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import com.droiddeck.launcher.R + +/** Actions for the phone while the picture is on the glasses. Null hides the button. */ +internal class GlassesPhoneActions( + val onRecenter: (() -> Unit)?, + val onRecenterJoyCons: (() -> Unit)?, + val onSteamVrMenu: (() -> Unit)?, + val onSwitchSticks: (() -> Unit)?, + val controllers: String?, + val onNextControllers: (() -> Unit)?, + val onKeyboard: () -> Unit, + val onSessionMenu: () -> Unit, + val onStopSteamVr: (() -> Unit)?, + val brightness: Int, + val brightnessMax: Int, + val onBrightness: ((Int) -> Unit)?, +) + +@OptIn(ExperimentalLayoutApi::class) +@Composable +internal fun GlassesPhonePanel(model: String, status: String?, a: GlassesPhoneActions) { + Box(Modifier.fillMaxSize().windowInsetsPadding(WindowInsets.displayCutout).padding(16.dp), contentAlignment = Alignment.Center) { + Column(horizontalAlignment = Alignment.CenterHorizontally, modifier = Modifier.widthIn(max = 640.dp)) { + Icon(GlassesIcon, null, tint = Color.White.copy(alpha = 0.35f), modifier = Modifier.size(40.dp)) + Spacer(Modifier.height(6.dp)) + Text(stringResource(R.string.glasses_playing, model), color = Color.White.copy(alpha = 0.6f), fontSize = 15.sp) + if (status != null) Text(status, color = Color.White.copy(alpha = 0.4f), fontSize = 13.sp, textAlign = TextAlign.Center) + Spacer(Modifier.height(16.dp)) + FlowRow(horizontalArrangement = Arrangement.spacedBy(10.dp, Alignment.CenterHorizontally), + verticalArrangement = Arrangement.spacedBy(10.dp)) { + a.onRecenter?.let { PanelButton(stringResource(R.string.glasses_phone_recenter), "phone-recenter", it) } + a.onRecenterJoyCons?.let { PanelButton(stringResource(R.string.glasses_recenter_joycons_button), "phone-recenter-joycons", it) } + a.onSteamVrMenu?.let { PanelButton(stringResource(R.string.glasses_phone_steamvr_menu), "phone-steamvr-menu", it) } + a.onNextControllers?.let { next -> a.controllers?.let { + PanelButton(stringResource(R.string.glasses_phone_controllers, it), "phone-controllers", next) } } + a.onSwitchSticks?.let { PanelButton(stringResource(R.string.glasses_phone_switch_sticks), "phone-switch-sticks", it) } + PanelButton(stringResource(R.string.glasses_phone_keyboard), "phone-keyboard", a.onKeyboard) + PanelButton(stringResource(R.string.glasses_phone_session_menu), "phone-session-menu", a.onSessionMenu) + a.onStopSteamVr?.let { PanelButton(stringResource(R.string.glasses_phone_stop_steamvr), "phone-stop-steamvr", it) } + } + val setBrightness = a.onBrightness + if (setBrightness != null && a.brightnessMax > 0) { + Spacer(Modifier.height(14.dp)) + Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp)) { + PanelButton("−", "phone-brightness-down") { setBrightness((a.brightness - 1).coerceAtLeast(0)) } + Text(stringResource(R.string.glasses_phone_brightness, a.brightness.coerceAtLeast(0), a.brightnessMax), + color = Color.White.copy(alpha = 0.6f), fontSize = 14.sp) + PanelButton("+", "phone-brightness-up") { setBrightness((a.brightness + 1).coerceAtMost(a.brightnessMax)) } + } + } + } + } +} + +@Composable +private fun PanelButton(label: String, tag: String, onClick: () -> Unit) = + SecondaryButton(label, compact = true, modifier = Modifier.testTag(tag), onClick = onClick) diff --git a/app/src/main/java/com/droiddeck/launcher/ui/LogoPositionDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/LogoPositionDialog.kt index 7e42aab512..2ddbdbe287 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/LogoPositionDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/LogoPositionDialog.kt @@ -3,6 +3,9 @@ package com.droiddeck.launcher.ui import androidx.compose.foundation.background import androidx.compose.foundation.border import androidx.compose.foundation.clickable +import androidx.compose.ui.focus.focusRequester +import androidx.compose.ui.focus.FocusRequester +import androidx.compose.runtime.LaunchedEffect import androidx.compose.foundation.hoverable import androidx.compose.foundation.interaction.MutableInteractionSource import androidx.compose.foundation.layout.Arrangement @@ -105,7 +108,7 @@ private fun LogoPreview(hero: File?, logo: File?, value: LogoPosition.Value) { } @Composable -private fun PinChip(label: String, selected: Boolean, onClick: () -> Unit) { +private fun PinChip(label: String, selected: Boolean, focus: FocusRequester?, onClick: () -> Unit) { val pal = LocalPalette.current val colors = MaterialTheme.colorScheme val src = remember { MutableInteractionSource() } @@ -113,7 +116,7 @@ private fun PinChip(label: String, selected: Boolean, onClick: () -> Unit) { val shape = RoundedCornerShape(8.dp) Box( contentAlignment = Alignment.Center, - modifier = Modifier.clip(shape) + modifier = Modifier.then(if (focus != null) Modifier.focusRequester(focus) else Modifier).clip(shape) .background(if (selected) pal.signal.copy(alpha = 0.14f) else Color.White.copy(alpha = 0.03f)) .border(if (selected) 2.dp else 1.dp, if (selected) pal.signal else pal.line, shape) .glideBorder(hot, shape, pal.signal) @@ -140,6 +143,9 @@ internal fun LogoPositionDialog( val shown = rememberShown(onBack) val back = { shown.targetState = false } var value by remember { mutableStateOf(start ?: LogoPosition.DEFAULT) } + val startPin = remember { value.pin } + val first = remember { FocusRequester() } + LaunchedEffect(Unit) { focusSoon { first } } var failed by remember { mutableStateOf(false) } var busy by remember { mutableStateOf(false) } val save: (LogoPosition.Value?) -> Unit = { next -> @@ -172,7 +178,7 @@ internal fun LogoPositionDialog( ) Text(stringResource(R.string.logo_pos_position), fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(start = 2.dp, top = 2.dp)) FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { - for (pin in LogoPosition.Pin.values()) PinChip(pin.label(), pin == value.pin) { value = value.copy(pin = pin) } + for (pin in LogoPosition.Pin.values()) PinChip(pin.label(), pin == value.pin, if (pin == startPin) first else null) { value = value.copy(pin = pin) } } ValueSlider( value.widthPct, LogoPosition.MIN_PCT..LogoPosition.MAX_PCT, step = 1, enabled = true, label = stringResource(R.string.logo_pos_size), diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt index d90747aca4..cb7ec92516 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt @@ -14,6 +14,7 @@ import androidx.compose.material3.LinearProgressIndicator import androidx.compose.material3.TextButton import androidx.compose.runtime.Composable import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.setValue @@ -81,6 +82,8 @@ class ModeSettings( val picturePosition: String? = null, val stretch16x9: Boolean? = null, val steamClientArch: String? = null, + /** Steam only: a game launched from the front end returns there when it closes; null hides the row. */ + val returnAfterGame: Boolean? = null, val steamRepairQueued: Boolean = false, val mangoapp: Boolean = true, val steamController: String? = null, @@ -98,6 +101,7 @@ class ModeSettings( val wifiDiscoveryBlocked: Boolean = false, val deckyInstalled: String? = null, val deckyLatestRelease: DeckyManager.Release? = null, + val deckyBranch: Int = DeckyManager.BRANCH_STABLE, val deckyChecking: Boolean = false, val deckyStage: String? = null, val deckyPercent: Int = -1, @@ -133,6 +137,7 @@ class ModeSettingsActions( val onSteamRepair: () -> Unit = {}, val onSteamClientArch: (String) -> Unit = {}, val onMangoapp: (Boolean) -> Unit = {}, + val onReturnAfterGame: (Boolean) -> Unit = {}, val onSteamController: (String) -> Unit = {}, val onUnfoldedControls: (Boolean) -> Unit = {}, val onRunSteamAtStartup: (Boolean) -> Unit = {}, @@ -144,6 +149,7 @@ class ModeSettingsActions( val onWifiDiscoverySettings: () -> Unit = {}, val onDeckyInstall: (DeckyManager.Release) -> Unit = {}, val onDeckyCheck: () -> Unit = {}, + val onDeckyBranch: (Int) -> Unit = {}, val onDeckyEnabled: (Boolean) -> Unit = {}, val onDeckyUninstall: () -> Unit = {}, val onPickDeckyPluginZip: () -> Unit = {}, @@ -273,8 +279,10 @@ fun ModeSheetRows(s: ModeSettings, a: ModeSettingsActions, tab: String, extras: SessionPrefs.CONTROLLER_DS4 to stringResource(R.string.mode_controller_ds4), SessionPrefs.CONTROLLER_DUALSENSE to stringResource(R.string.mode_controller_dualsense), SessionPrefs.CONTROLLER_XBOX360 to stringResource(R.string.mode_controller_x360), + SessionPrefs.CONTROLLER_NONE to stringResource(R.string.second_mode_none), ), s.steamController, - note = stringResource(R.string.mode_controller_note), + note = if (s.steamController == SessionPrefs.CONTROLLER_NONE) stringResource(R.string.common_applies_next_session) + else stringResource(R.string.mode_controller_note), onPick = a.onSteamController, ) if (steam && s.unfoldedControls != null) ToggleRow( @@ -423,6 +431,19 @@ fun ModeSheetRows(s: ModeSettings, a: ModeSettingsActions, tab: String, extras: if (s.deckyInstalled != null) DeckyUninstall(enabled = s.deckyStage == null && !s.deckySessionRunning, onUninstall = a.onDeckyUninstall) } } + ChoiceRow( + host, "decky-channel", stringResource(R.string.decky_channel), + stringResource(R.string.decky_channel_hint), + listOf( + DeckyManager.BRANCH_STABLE to stringResource(R.string.decky_channel_stable), + DeckyManager.BRANCH_PRERELEASE to stringResource(R.string.decky_channel_prerelease), + ) + if (s.deckyBranch == DeckyManager.BRANCH_TESTING) listOf( + DeckyManager.BRANCH_TESTING to stringResource(R.string.decky_channel_testing), + ) else emptyList(), + s.deckyBranch, + enabled = s.deckyStage == null && !s.deckySessionRunning, + onPick = a.onDeckyBranch, + ) if (s.deckyInstalled != null) ToggleRow( host, "decky-enabled", stringResource(R.string.mode_decky), if (s.deckyEnabled) stringResource(R.string.mode_decky_on) @@ -454,6 +475,11 @@ fun ModeSheetRows(s: ModeSettings, a: ModeSettingsActions, tab: String, extras: stringResource(R.string.mode_mangoapp_hint), s.mangoapp, onChange = a.onMangoapp, ) + if (s.returnAfterGame != null) ToggleRow( + host, "returnaftergame", stringResource(R.string.mode_return_after_game), + stringResource(R.string.mode_return_after_game_hint), + s.returnAfterGame, onChange = a.onReturnAfterGame, + ) SettingsRow( stringResource(R.string.mode_steam_repair), stringResource(if (s.steamRepairQueued) R.string.mode_steam_repair_queued else R.string.mode_steam_repair_hint), @@ -529,6 +555,35 @@ internal fun ProtonOptions( GameEnvironmentRow() } +@Composable +internal fun DeckyZipWarningDialog(onConfirm: () -> Unit, onCancel: () -> Unit) { + val context = androidx.compose.ui.platform.LocalContext.current + var left by remember { mutableIntStateOf(if (SessionPrefs.deckyZipWarningSeen(context)) 0 else DECKY_ZIP_WARNING_SECONDS) } + androidx.compose.runtime.LaunchedEffect(Unit) { + while (left > 0) { + kotlinx.coroutines.delay(1000L) + left-- + } + SessionPrefs.setDeckyZipWarningSeen(context) + } + AlertDialog( + onDismissRequest = onCancel, + title = { Text(stringResource(R.string.decky_zip_warning_title)) }, + text = { Text(stringResource(R.string.decky_zip_warning_text)) }, + confirmButton = { + androidx.compose.material3.TextButton(onClick = onConfirm, enabled = left == 0) { + Text( + if (left > 0) androidx.compose.ui.res.pluralStringResource(R.plurals.decky_zip_warning_wait, left, left) + else stringResource(R.string.decky_zip_warning_continue), + ) + } + }, + dismissButton = { androidx.compose.material3.TextButton(onClick = onCancel) { Text(stringResource(R.string.common_cancel)) } }, + ) +} + +private const val DECKY_ZIP_WARNING_SECONDS = 5 + @Composable private fun DeckyUninstall(enabled: Boolean, onUninstall: () -> Unit) { val colors = MaterialTheme.colorScheme diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenControls.kt b/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt similarity index 89% rename from app/src/main/java/com/droiddeck/launcher/ui/SecondScreenControls.kt rename to app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt index 908b00e0a0..df972e00f4 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenControls.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenPresentation.kt @@ -1,17 +1,21 @@ package com.droiddeck.launcher.ui import com.droiddeck.launcher.R +import android.app.Presentation import android.content.ClipboardManager import android.content.Context import android.graphics.Canvas import android.graphics.Color +import android.os.Bundle import android.util.Log +import android.view.Display import android.view.Gravity import android.view.KeyEvent import android.view.MotionEvent import android.view.View import android.view.ViewGroup import android.view.ViewConfiguration +import android.view.WindowManager import android.view.inputmethod.InputMethodManager import android.widget.Button import android.widget.FrameLayout @@ -33,9 +37,9 @@ import com.termux.terminal.TerminalSessionClient import com.termux.view.TerminalView import com.termux.view.TerminalViewClient -internal class SecondScreenControls( - context: Context, +class SecondScreenPresentation( private val sessionActivity: SessionActivity, + display: Display, private val sendPointer: (x: Float, y: Float, width: Float, height: Float) -> Unit, private val sendButton: (button: Int, pressed: Boolean) -> Unit, private val sendWheel: (steps: Int) -> Unit, @@ -43,8 +47,12 @@ internal class SecondScreenControls( private val onQam: () -> Unit, private val onClose: () -> Unit, private val pad: PadBridge? = null, -) : LinearLayout(context) { - private val root get() = this +) : Presentation(sessionActivity, display) { + private val root = LinearLayout(context).apply { + orientation = LinearLayout.VERTICAL + setBackgroundColor(Color.rgb(15, 18, 22)) + isFocusableInTouchMode = true + } private var currentMode = SecondScreenMode.NONE private var keyboardHost: KeyboardHost? = null private var terminalSession: TerminalSession? = null @@ -52,22 +60,35 @@ internal class SecondScreenControls( private var terminalPid = -1 private var ctrlActive = false private var altActive = false + private var created = false + init { - orientation = VERTICAL - setBackgroundColor(Color.rgb(15, 18, 22)) - isFocusableInTouchMode = true + setCancelable(false) + setCanceledOnTouchOutside(false) + setOnDismissListener { closeTerminal() } + } + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + created = true + window?.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) + window?.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE) + setContentView(root) + applyImmersiveMode() + renderMode() } fun showMode(mode: SecondScreenMode) { - if (currentMode == mode) return + if (currentMode == mode && isShowing) return currentMode = mode - renderMode() + if (created) renderMode() } fun closeControls() { closeTerminal() keyboardHost?.hide() keyboardHost = null + dismiss() } override fun dispatchKeyEvent(event: KeyEvent): Boolean { @@ -77,14 +98,24 @@ internal class SecondScreenControls( return super.dispatchKeyEvent(event) } + override fun onWindowFocusChanged(hasFocus: Boolean) { + super.onWindowFocusChanged(hasFocus) + if (hasFocus) { + applyImmersiveMode() + sessionActivity.refreshClipboard() + } + } + private fun renderMode() { keyboardHost?.hide() keyboardHost = null closeTerminal() root.removeAllViews() - if (currentMode == SecondScreenMode.NONE) return + val mode = if (currentMode == SecondScreenMode.DECK_CONTROLS && !SessionState.deckPad) SecondScreenMode.NONE + else currentMode + if (mode == SecondScreenMode.NONE) return - when (currentMode) { + when (mode) { SecondScreenMode.KEYBOARD_TRACKPAD -> renderKeyboardAndTrackpad() SecondScreenMode.TERMINAL -> renderTerminal() SecondScreenMode.DECK_CONTROLS -> root.addView(DeckControlsPanel(context, onClose, onSteamMenu, onQam, pad), weightParams()) @@ -262,6 +293,16 @@ internal class SecondScreenControls( private fun weightParams() = LinearLayout.LayoutParams(-1, 0, 1f) + private fun applyImmersiveMode() { + @Suppress("DEPRECATION") + window?.decorView?.systemUiVisibility = (View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY + or View.SYSTEM_UI_FLAG_FULLSCREEN + or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION + or View.SYSTEM_UI_FLAG_LAYOUT_STABLE + or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN + or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION) + } + private inner class TrackpadView(context: Context) : View(context) { private val gestures = TouchpadGestures(ViewConfiguration.get(context).scaledTouchSlop.toFloat(), object : PointerGestures.Listener { diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenWindow.kt b/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenWindow.kt deleted file mode 100644 index 55efd2a006..0000000000 --- a/app/src/main/java/com/droiddeck/launcher/ui/SecondScreenWindow.kt +++ /dev/null @@ -1,139 +0,0 @@ -package com.droiddeck.launcher.ui - -import android.app.Activity -import android.app.ActivityOptions -import android.content.Intent -import android.os.Bundle -import android.view.Display -import android.view.View -import android.view.WindowManager -import com.droiddeck.launcher.SessionActivity -import com.droiddeck.launcher.input.PadBridge -import com.droiddeck.launcher.input.SecondScreenMode -import com.droiddeck.launcher.session.SessionState -import java.lang.ref.WeakReference -import java.util.concurrent.atomic.AtomicLong - -class SecondScreenWindow( - private val sessionActivity: SessionActivity, - val display: Display, - private val sendPointer: (Float, Float, Float, Float) -> Unit, - private val sendButton: (Int, Boolean) -> Unit, - private val sendWheel: (Int) -> Unit, - private val onSteamMenu: () -> Unit, - private val onQam: () -> Unit, - private val onClose: () -> Unit, - private val pad: PadBridge? = null, -) { - private val token = tokens.incrementAndGet() - private var activity = WeakReference(null) - private var controls: SecondScreenControls? = null - private var mode = SecondScreenMode.NONE - private var launching = false - private var closed = false - val window get() = activity.get()?.window - val isShowing get() = !closed && (launching || activity.get()?.isFinishing == false) - - fun show() { - if (isShowing || closed) return - owners[token] = WeakReference(this) - launching = true - try { - val intent = Intent(sessionActivity, SecondScreenActivity::class.java) - .putExtra(OWNER, token) - .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_MULTIPLE_TASK) - sessionActivity.startActivity(intent, ActivityOptions.makeBasic().setLaunchDisplayId(display.displayId).toBundle()) - } catch (error: Exception) { - launching = false - owners.remove(token) - throw error - } - } - - fun showMode(mode: SecondScreenMode) { - this.mode = mode - controls?.showMode(mode) - } - - fun closeControls() { - closed = true - launching = false - owners.remove(token) - controls?.closeControls() - controls = null - activity.get()?.finishAndRemoveTask() - activity.clear() - } - - internal fun attach(host: SecondScreenActivity): View { - controls?.closeControls() - activity = WeakReference(host) - launching = false - return SecondScreenControls(host, sessionActivity, sendPointer, sendButton, sendWheel, - onSteamMenu, onQam, onClose, pad).also { - controls = it - it.showMode(mode) - } - } - - internal fun detach(host: SecondScreenActivity) { - if (activity.get() !== host) return - controls?.closeControls() - controls = null - activity.clear() - if (host.isFinishing && !closed) onClose() - } - - internal fun refreshClipboard() = sessionActivity.refreshClipboard() - - companion object { - private const val OWNER = "secondScreenOwner" - private val tokens = AtomicLong() - private val owners = mutableMapOf>() - internal fun find(intent: Intent): SecondScreenWindow? = - owners[intent.getLongExtra(OWNER, 0)]?.get()?.takeUnless { it.closed } - } -} - -class SecondScreenActivity : Activity() { - private var owner: SecondScreenWindow? = null - - override fun onCreate(savedInstanceState: Bundle?) { - super.onCreate(savedInstanceState) - val host = SecondScreenWindow.find(intent) - if (host == null || !SessionState.running) { - finishAndRemoveTask() - return - } - owner = host - window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) - window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE) - setContentView(host.attach(this)) - applyImmersiveMode() - } - - override fun onWindowFocusChanged(hasFocus: Boolean) { - super.onWindowFocusChanged(hasFocus) - if (hasFocus) { - applyImmersiveMode() - owner?.refreshClipboard() - } - } - - @Deprecated("Back is handled by the session controls") - override fun onBackPressed() = Unit - - override fun onDestroy() { - owner?.detach(this) - owner = null - super.onDestroy() - } - - private fun applyImmersiveMode() { - @Suppress("DEPRECATION") - window.decorView.systemUiVisibility = (View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY - or View.SYSTEM_UI_FLAG_FULLSCREEN or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION - or View.SYSTEM_UI_FLAG_LAYOUT_STABLE or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN - or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION) - } -} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SessionLoading.kt b/app/src/main/java/com/droiddeck/launcher/ui/SessionLoading.kt index bf41dcf0b8..4a0adea2d4 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SessionLoading.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionLoading.kt @@ -27,6 +27,7 @@ import androidx.compose.foundation.layout.heightIn import androidx.compose.material.icons.filled.Pause import androidx.compose.foundation.rememberScrollState import androidx.compose.material3.Icon +import androidx.compose.foundation.Canvas import androidx.compose.foundation.background import androidx.compose.foundation.clickable import androidx.compose.foundation.interaction.MutableInteractionSource @@ -68,6 +69,8 @@ import androidx.compose.ui.draw.clip import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusRequester import androidx.compose.ui.graphics.Brush +import androidx.compose.ui.graphics.Path +import androidx.compose.ui.graphics.StrokeCap import androidx.compose.ui.semantics.contentDescription import androidx.compose.ui.semantics.semantics import androidx.compose.ui.text.font.FontWeight @@ -78,21 +81,93 @@ import androidx.compose.ui.text.style.TextOverflow @Composable -fun HudText(text: String) { +fun HudText(text: String, graph: FloatArray = FloatArray(0), color: String = "mint", opacity: Int = 70) { + if (text.isEmpty() && graph.size < 2) return + val accent = hudInk(color) + val wash = (opacity.coerceIn(30, 100) / 100f) + val ink = accent.copy(alpha = (0.5f + wash * 0.5f).coerceIn(0.62f, 1f)) Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.TopEnd) { - Text( - text, - fontFamily = FontFamily.Monospace, - fontSize = 12.sp, - color = Color.White, + Column( + horizontalAlignment = Alignment.End, modifier = Modifier .padding(12.dp) - .background(Color(0x8C000000)) - .padding(horizontal = 8.dp, vertical = 3.dp), - ) + .background( + Brush.verticalGradient( + listOf(accent.copy(alpha = wash * 0.28f), Color.Black.copy(alpha = wash * 0.72f)), + ), + RoundedCornerShape(8.dp), + ) + .padding(horizontal = 8.dp, vertical = 5.dp), + ) { + if (text.isNotEmpty()) Text( + text, + fontFamily = FontFamily.Monospace, + fontSize = 12.sp, + color = ink, + textAlign = TextAlign.End, + ) + if (graph.size >= 2) { + if (text.isNotEmpty()) Spacer(Modifier.height(4.dp)) + HudGraph(graph, accent, wash) + } + } } } +@Composable +private fun HudGraph(samples: FloatArray, accent: Color, wash: Float) { + Canvas(Modifier.width(148.dp).height(44.dp)) { + val maxMs = (samples.maxOrNull() ?: 16.7f).coerceAtLeast(16.7f) + val step = size.width / (samples.size - 1) + fun yOf(ms: Float) = size.height * (1f - (ms / maxMs).coerceIn(0f, 1f)) + val fillAlpha = wash * 0.5f + val fill = Path().apply { + moveTo(0f, size.height) + samples.forEachIndexed { i, ms -> lineTo(i * step, yOf(ms)) } + lineTo(size.width, size.height) + close() + } + drawPath( + fill, + Brush.verticalGradient(listOf(HUD_SLOW.copy(alpha = fillAlpha), accent.copy(alpha = fillAlpha * 0.45f))), + ) + val guide = yOf(16.7f) + drawLine(Color.White.copy(alpha = 0.32f), Offset(0f, guide), Offset(size.width, guide), strokeWidth = 1f) + for (i in 0 until samples.lastIndex) { + val tone = ((samples[i] - 8f) / 25f).coerceIn(0f, 1f) + drawLine( + mix(accent, HUD_SLOW, tone).copy(alpha = 0.55f + wash * 0.4f), + Offset(i * step, yOf(samples[i])), + Offset((i + 1) * step, yOf(samples[i + 1])), + strokeWidth = 2.5f, + cap = StrokeCap.Round, + ) + } + } +} + +private fun hudInk(color: String): Color = Color( + when (color) { + "white" -> 0xFFF2F5F8 + "sky" -> 0xFF66C0F4 + "amber" -> 0xFFFFB74D + "violet" -> 0xFFD0A2FF + else -> 0xFF3DDC84 + }.toInt(), +) + +private fun mix(from: Color, to: Color, t: Float): Color { + val u = t.coerceIn(0f, 1f) + return Color( + red = from.red + (to.red - from.red) * u, + green = from.green + (to.green - from.green) * u, + blue = from.blue + (to.blue - from.blue) * u, + alpha = 1f, + ) +} + +private val HUD_SLOW = Color(0xFFFF5C6C.toInt()) + private class LoadStage(@androidx.annotation.StringRes val label: Int, @androidx.annotation.StringRes val detail: Int) private fun loadStages(steam: Boolean): List = if (steam) listOf( @@ -146,7 +221,7 @@ fun LoadingOverlay( modifier = Modifier .fillMaxSize() .background(colors.background) - .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null) {}, + .blockTouches(), ) { CapsuleWall(games, driftMs = 65_000, modifier = Modifier.alpha(0.3f)) Box( @@ -275,7 +350,6 @@ private fun CancelHint(onCancel: () -> Unit, modifier: Modifier = Modifier) { fun SessionPausedOverlay(title: String = stringResource(R.string.load_steam_paused), onResume: () -> Unit) { val colors = MaterialTheme.colorScheme val pal = LocalPalette.current - val interactionSource = remember { MutableInteractionSource() } val resumeFocus = remember { FocusRequester() } LaunchedEffect(Unit) { androidx.compose.runtime.withFrameNanos { } @@ -285,7 +359,7 @@ fun SessionPausedOverlay(title: String = stringResource(R.string.load_steam_paus modifier = Modifier .fillMaxSize() .background(pal.background.copy(alpha = 0.94f)) - .clickable(interactionSource = interactionSource, indication = null) {}, + .blockTouches(), contentAlignment = Alignment.Center, ) { Column( diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt index 6fa4cba7b6..ef55dd2882 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt @@ -103,6 +103,7 @@ import androidx.compose.animation.slideOutHorizontally import androidx.compose.foundation.LocalIndication import androidx.compose.foundation.border import androidx.compose.foundation.focusable +import androidx.compose.ui.focus.focusProperties import androidx.compose.foundation.hoverable import androidx.compose.foundation.interaction.collectIsFocusedAsState import androidx.compose.foundation.interaction.collectIsHoveredAsState @@ -110,6 +111,7 @@ import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.mutableStateMapOf import androidx.compose.runtime.remember import androidx.compose.runtime.saveable.rememberSaveable import androidx.compose.runtime.setValue @@ -195,6 +197,11 @@ class DrawerActions( val isHomeApp: Boolean, val androidApps: List, val hudOn: Boolean, + val hudFps: Boolean = true, + val hudBattery: Boolean = true, + val hudGraph: Boolean = true, + val hudColor: String = SessionPrefs.HUD_COLOR_MINT, + val hudOpacity: Int = SessionPrefs.HUD_OPACITY_DEFAULT, val frameGen: FrameGen.Mode, val lossless: Lossless.State, val oscMode: String, @@ -222,6 +229,11 @@ class DrawerActions( val secondScreenDisplays: List, val selectedSecondScreenDisplay: Int, val onHud: (Boolean) -> Unit, + val onHudFps: (Boolean) -> Unit = {}, + val onHudBattery: (Boolean) -> Unit = {}, + val onHudGraph: (Boolean) -> Unit = {}, + val onHudColor: (String) -> Unit = {}, + val onHudOpacity: (Int) -> Unit = {}, val onFrameGenPick: (FrameGen.Mode) -> Unit, val onImportLossless: () -> Unit, val onKeyboard: () -> Unit, @@ -308,7 +320,7 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont val pal = LocalPalette.current val host = rememberMenuHost() val (glasses, glassesSettings) = rememberGlasses() - val glassesPages = glassesTabs(glasses) + val glassesPages = glassesTabs(glasses) + (GlassesTab.CONTROLLERS to stringResource(R.string.vr_controllers_tab)) var selectedGlassesTab by rememberSaveable { mutableStateOf(GlassesTab.DISPLAY) } val glassesTab = selectedGlassesTab.takeIf { key -> glassesPages.any { it.first == key } } ?: GlassesTab.DISPLAY var androidAppsExpanded by rememberSaveable { mutableStateOf(false) } @@ -373,10 +385,15 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont focus.request(first) } } - if (open || veil > 0.01f) Box( - modifier = Modifier.fillMaxSize() - .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null) { host.open = null; a.onClose() }, - ) + if (open || veil > 0.01f) { + val closeLabel = stringResource(R.string.common_close) + Box( + modifier = Modifier.fillMaxSize() + .focusProperties { canFocus = false } + .semantics { contentDescription = closeLabel } + .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null, onClickLabel = closeLabel) { host.open = null; a.onClose() }, + ) + } androidx.compose.foundation.layout.BoxWithConstraints(modifier = Modifier.fillMaxSize().exposeTestTags(), contentAlignment = Alignment.CenterEnd) { val short = maxHeight < 440.dp val sheetWidth = minOf(360.dp, maxWidth * 0.92f) @@ -390,7 +407,7 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont modifier = Modifier .fillMaxSize() .background(pal.background.copy(alpha = 0.97f)) - .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null) {} + .blockTouches() .focusGroup() .controllerBack { if (host.open != null) host.open = null else a.onClose() @@ -462,6 +479,30 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont SettingsGroup(stringResource(R.string.drawer_page_display)) { ToggleRow(host, "hud", stringResource(R.string.drawer_hud), null, a.hudOn, chipModifier = focus.track(page, "hud"), onChange = a.onHud) + if (a.hudOn) { + ToggleRow(host, "hud-fps", stringResource(R.string.drawer_hud_fps), null, a.hudFps, + chipModifier = focus.track(page, "hud-fps"), onChange = a.onHudFps) + ToggleRow(host, "hud-battery", stringResource(R.string.drawer_hud_battery), null, a.hudBattery, + chipModifier = focus.track(page, "hud-battery"), onChange = a.onHudBattery) + ToggleRow(host, "hud-graph", stringResource(R.string.drawer_hud_graph), null, a.hudGraph, + chipModifier = focus.track(page, "hud-graph"), onChange = a.onHudGraph) + ChoiceRow( + host, "hud-color", stringResource(R.string.drawer_hud_color), null, + listOf( + SessionPrefs.HUD_COLOR_MINT to stringResource(R.string.drawer_hud_color_mint), + "white" to stringResource(R.string.drawer_hud_color_white), + "sky" to stringResource(R.string.drawer_hud_color_sky), + "amber" to stringResource(R.string.drawer_hud_color_amber), + "violet" to stringResource(R.string.drawer_hud_color_violet), + ), + a.hudColor, chipModifier = focus.track(page, "hud-color"), onPick = a.onHudColor, + ) + SliderRow( + stringResource(R.string.drawer_hud_opacity), null, a.hudOpacity, + SessionPrefs.HUD_OPACITY_RANGE, step = 10, format = { "$it%" }, + modifier = focus.track(page, "hud-opacity"), onChange = a.onHudOpacity, + ) + } val fgOpen = host.open == "fg" val fgLabel = FrameGen.label(LocalContext.current, a.frameGen) SettingsRow(stringResource(R.string.frame_gen_title), null, highlighted = fgOpen) { @@ -557,7 +598,9 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont SessionDrawerPage.SECOND_SCREEN -> { SecondScreenGroup(host, a) { key -> focus.track(page, key) } } - SessionDrawerPage.GLASSES -> { + SessionDrawerPage.GLASSES -> if (glassesTab == GlassesTab.CONTROLLERS) { + VrControllerGroups(host) { key -> focus.track(page, key) } + } else { GlassesGroups(host, glasses, glassesSettings, { key -> focus.track(page, key) }, onRecenter = a.onGlassesRecenter, tab = glassesTab, outputActive = a.glassesOutput, steamVrRunning = a.steamVr == SteamVr.Status.RUNNING, steamVr = { SteamVrRow(a) }) @@ -1379,6 +1422,7 @@ internal fun ComponentDownloadsDrawerGroup( ) { val colors = MaterialTheme.colorScheme val installed = packages.map { it.file }.toSet() + val nightlyPicked = remember { mutableStateMapOf() } SettingsGroup(stringResource(R.string.drawer_component_downloads)) { Text(stringResource(R.string.drawer_component_downloads_hint), fontSize = 12.sp, color = colors.onSurfaceVariant, modifier = Modifier.padding(horizontal = 14.dp, vertical = 8.dp)) @@ -1402,21 +1446,40 @@ internal fun ComponentDownloadsDrawerGroup( } AnchoredMenu(open, onDismiss = { if (host.open == key) host.open = null }, title = ComponentsManager.LABEL.getValue(comp)) { firstItemFocus -> - val firstAvailable = items.firstOrNull { ComponentsManager.safeName(it.file) !in installed && it.file !in downloads } - items.forEach { item -> + // A nightly paired with a stable build rides on that row; Stable/Nightly tabs beside the row pick which one. + val pairs = ComponentsManager.nightlyPairs(items) + val rows = items.filter { it !in pairs.values } + fun shown(row: ComponentsManager.CatalogItem) = pairs[row]?.takeIf { nightlyPicked[row.file] == true } ?: row + val firstAvailable = rows.firstOrNull { shown(it).let { s -> ComponentsManager.safeName(s.file) !in installed && s.file !in downloads } } + rows.forEach { row -> + val item = shown(row) + val nightly = pairs[row] val stored = ComponentsManager.safeName(item.file) in installed val progress = downloads[item.file] - MenuItem(item.file.removeSuffix(".wcp"), checked = stored, - enabled = !stored && progress == null, - detail = when { - stored -> stringResource(R.string.wincomp_downloaded) - progress != null -> if (progress < 0) stringResource(R.string.wincomp_downloading, item.file.removeSuffix(".wcp")) else "$progress%" - else -> item.release + " · " + stringResource(R.string.common_size_mb, item.size / 1048576.0) - }, - focusRequester = if (item == firstAvailable) firstItemFocus else null, - ) { - onDownload(item) - host.open = null + val choose = @Composable { rowModifier: Modifier -> + MenuItem(item.file.removeSuffix(".wcp"), checked = stored, + enabled = !stored && progress == null, + detail = when { + stored -> stringResource(R.string.wincomp_downloaded) + progress != null -> if (progress < 0) stringResource(R.string.wincomp_downloading, item.file.removeSuffix(".wcp")) else "$progress%" + else -> item.release + " · " + stringResource(R.string.common_size_mb, item.size / 1048576.0) + }, + focusRequester = if (row == firstAvailable) firstItemFocus else null, + modifier = rowModifier, + ) { + onDownload(item) + host.open = null + } + } + if (nightly == null) choose(Modifier) + else Row(verticalAlignment = Alignment.CenterVertically) { + choose(Modifier.weight(1f)) + TabStrip( + listOf(stringResource(R.string.comp_channel_stable), stringResource(R.string.comp_channel_nightly)), + selected = if (item === nightly) 1 else 0, + onSelect = { nightlyPicked[row.file] = it == 1 }, + bumpers = false, compact = true, modifier = Modifier.padding(start = 6.dp, end = 4.dp), + ) } } } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SettingsWidgets.kt b/app/src/main/java/com/droiddeck/launcher/ui/SettingsWidgets.kt index fb92473338..40619ee940 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SettingsWidgets.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SettingsWidgets.kt @@ -34,7 +34,9 @@ import androidx.compose.foundation.Canvas import androidx.compose.foundation.background import androidx.compose.foundation.border import androidx.compose.foundation.clickable +import androidx.compose.foundation.gestures.detectTapGestures import androidx.compose.foundation.hoverable +import androidx.compose.ui.input.pointer.pointerInput import androidx.compose.foundation.interaction.MutableInteractionSource import androidx.compose.foundation.interaction.collectIsFocusedAsState import androidx.compose.foundation.interaction.collectIsHoveredAsState @@ -141,6 +143,11 @@ internal fun Modifier.controllerBack(onBack: () -> Unit): Modifier = onPreviewKe } } +internal fun Modifier.blockTouches(): Modifier = pointerInput(Unit) { detectTapGestures { } } + +internal fun Modifier.tapOutside(onTap: () -> Unit): Modifier = + pointerInput(onTap) { detectTapGestures(onTap = { onTap() }) } + internal fun Modifier.bumpers(onPrevious: () -> Unit, onNext: () -> Unit): Modifier = onPreviewKeyEvent { event -> val keyEvent = event.nativeKeyEvent val previous = keyEvent.keyCode == KeyEvent.KEYCODE_BUTTON_L1 @@ -157,6 +164,7 @@ internal fun Modifier.bumpers(onPrevious: () -> Unit, onNext: () -> Unit): Modif internal fun TabStrip( tabs: List, selected: Int, onSelect: (Int) -> Unit, modifier: Modifier = Modifier, focusRequesters: List? = null, + bumpers: Boolean = true, compact: Boolean = false, ) { val colors = MaterialTheme.colorScheme val pal = LocalPalette.current @@ -164,9 +172,9 @@ internal fun TabStrip( val scroll = rememberScrollState() var tight by remember(tabs) { mutableStateOf(false) } LaunchedEffect(scroll.maxValue) { if (scroll.maxValue in 1 until Int.MAX_VALUE) tight = true } - val tabPadding = if (tight) 10.dp else 16.dp + val tabPadding = if (compact) 10.dp else if (tight) 10.dp else 16.dp Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp), modifier = modifier) { - BumperKey("LB", stringResource(R.string.widgets_prev_tab)) { onSelect((selected + tabs.size - 1) % tabs.size) } + if (bumpers) BumperKey("LB", stringResource(R.string.widgets_prev_tab)) { onSelect((selected + tabs.size - 1) % tabs.size) } Row( modifier = Modifier.weight(1f, fill = false).clip(shape).background(colors.surfaceVariant).border(1.dp, pal.line2, shape) .horizontalScroll(scroll).padding(3.dp), @@ -180,7 +188,7 @@ internal fun TabStrip( val reveal = remember { androidx.compose.foundation.relocation.BringIntoViewRequester() } if (on) LaunchedEffect(Unit) { reveal.bringIntoView() } Text( - label, fontSize = 14.sp, fontWeight = if (on) FontWeight.Bold else FontWeight.SemiBold, maxLines = 1, + label, fontSize = if (compact) 12.sp else 14.sp, fontWeight = if (on) FontWeight.Bold else FontWeight.SemiBold, maxLines = 1, color = if (on) pal.onSignal else if (hot) colors.onBackground else colors.onSurfaceVariant, modifier = Modifier .bringIntoViewRequester(reveal) @@ -191,11 +199,11 @@ internal fun TabStrip( .glideBorder(hot, tabShape, if (on) colors.onBackground else pal.signal) .hoverable(src).clickable(interactionSource = src, indication = null, role = Role.Tab, onClick = pick) .controllerConfirm(onClick = pick) - .padding(horizontal = tabPadding, vertical = 12.dp), + .padding(horizontal = tabPadding, vertical = if (compact) 6.dp else 12.dp), ) } } - BumperKey("RB", stringResource(R.string.widgets_next_tab)) { onSelect((selected + 1) % tabs.size) } + if (bumpers) BumperKey("RB", stringResource(R.string.widgets_next_tab)) { onSelect((selected + 1) % tabs.size) } } } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SteamHome.kt b/app/src/main/java/com/droiddeck/launcher/ui/SteamHome.kt index 5dafd24280..dfb6d2525d 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SteamHome.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SteamHome.kt @@ -115,13 +115,14 @@ internal fun SteamHome(s: FrontEndState, a: FrontEndActions, modifier: Modifier) drop = drop.takeIf { headset }, overlay = { lifted -> if (headset) DropSheet( - drop, glassesTabs(glasses), covered = lifted, + drop, glassesTabs(glasses) + (GlassesTab.CONTROLLERS to stringResource(R.string.vr_controllers_tab)), covered = lifted, button = { enabled -> PrimaryButton(stringResource(R.string.games_play_steamvr), enabled = !s.busy && glasses.usable, large = true, icon = Icons.Filled.PlayArrow, fill = true, modifier = Modifier.fillMaxWidth().testTag("play-steamvr")) { if (enabled) { drop.open = false; a.onPlaySteamVr() } } }, ) { tab -> - GlassesGroups(rememberMenuHost(), glasses, glassesSettings, + if (tab == GlassesTab.CONTROLLERS) VrControllerGroups(rememberMenuHost()) + else GlassesGroups(rememberMenuHost(), glasses, glassesSettings, onRecenter = GlassesMenuMirror::recenter, inSession = false, tab = tab) } }, diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoreAchievementsUi.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoreAchievementsUi.kt index e0d5099a74..4f71f68b38 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoreAchievementsUi.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoreAchievementsUi.kt @@ -303,7 +303,7 @@ internal fun SessionAchievementsPanel(label: String, state: AchievementsState, t val slide = remember { MutableTransitionState(false).apply { targetState = true } } BoxWithConstraints( Modifier.fillMaxSize().background(veil) - .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null, onClick = onClose), + .tapOutside(onClose), contentAlignment = Alignment.CenterEnd, ) { val short = maxHeight < 440.dp @@ -312,7 +312,7 @@ internal fun SessionAchievementsPanel(label: String, state: AchievementsState, t (if (floating) Modifier.padding(12.dp).fillMaxHeight().width(minOf(420.dp, maxWidth * 0.92f)).clip(RoundedCornerShape(20.dp)) .background(pal.background).border(1.dp, pal.line2, RoundedCornerShape(20.dp)) else Modifier.fillMaxHeight().width(minOf(420.dp, maxWidth * 0.92f)).background(pal.background.copy(alpha = 0.97f))) - .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null) {} + .blockTouches() .controllerBack(onClose) .then(if (kinds.isEmpty()) Modifier else Modifier.bumpers({ pick = (pick + kinds.size - 1) % kinds.size }, { pick = (pick + 1) % kinds.size })) .padding(if (short) 12.dp else 16.dp), diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoresDetail.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoresDetail.kt index 3baa0054ae..b377f02ec1 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoresDetail.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoresDetail.kt @@ -51,7 +51,6 @@ import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.sp import coil.compose.AsyncImage import com.droiddeck.launcher.R -import com.droiddeck.launcher.stores.CatalogItem import com.droiddeck.launcher.stores.Store import com.droiddeck.launcher.stores.StoreAchievements import com.droiddeck.launcher.stores.StoresState @@ -68,7 +67,7 @@ internal fun StoreGameDetail(store: Store, key: String, s: FrontEndState, a: Fro val narrow = LocalNarrowPane.current val stacked = narrow || LocalConfiguration.current.screenWidthDp < 700 val id = key.substringAfter(':') - val item = (StoresState.library[store].orEmpty() + StoresState.shelves[store]?.all.orEmpty()).firstOrNull { it.id == id } + val item = StoresState.detailItem(store, id) val installed = StoresState.installedGame(store, id) val rawDownload = StoresState.download("${store.id}:$id") val download = rawDownload?.takeIf { it.isActive } @@ -86,18 +85,23 @@ internal fun StoreGameDetail(store: Store, key: String, s: FrontEndState, a: Fro .clip(Shape16).background(artBrush(hueOf(title))), ) { val art = item?.imageUrl ?: installed?.sidecar?.hero ?: installed?.sidecar?.cover - if (art != null) AsyncImage(model = art, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize()) + // The card it came from keeps its own bitmap under the hero until the wide art is decoded. + val heroArt = cardArtRequest(art, item?.tallImageUrl) + if (heroArt != null) AsyncImage(model = heroArt, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize()) Spacer(Modifier.matchParentSize().background(Brush.horizontalGradient(0f to colors.background.copy(alpha = 0.94f), 0.5f to colors.background.copy(alpha = 0.55f), 1f to Color.Transparent))) if (scores != null && !stacked) { Spacer(Modifier.matchParentSize().background(Brush.horizontalGradient(0.45f to Color.Transparent, 1f to colors.background.copy(alpha = 0.75f)))) HeroScores(scores, Modifier.align(Alignment.BottomEnd).padding(end = 16.dp, bottom = 18.dp)) } Column(verticalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.align(Alignment.BottomStart).padding(horizontal = 22.dp, vertical = 18.dp)) { + val passName = item?.includedWith.orEmpty() val state = when { installed != null -> stringResource(R.string.stores_eyebrow_installed) + " · " + com.droiddeck.launcher.stores.StoreInstallRoot.labelFor(ctx, installed.folder) download != null && download.location.isNotBlank() -> stringResource(R.string.stores_eyebrow_library) + " · " + download.location failedDownload != null && failedDownload.location.isNotBlank() -> stringResource(R.string.stores_eyebrow_library) + " · " + failedDownload.location - item?.subscription == true -> "PC Game Pass" + item?.owned == true -> stringResource(R.string.stores_eyebrow_library) + item?.subscription == true -> passName.ifBlank { "PC Game Pass" } + passName.isNotBlank() -> "Available with $passName" item?.accessible == true -> stringResource(R.string.stores_eyebrow_library) else -> stringResource(R.string.stores_eyebrow_store) } @@ -153,14 +157,25 @@ internal fun StoreGameDetail(store: Store, key: String, s: FrontEndState, a: Fro com.droiddeck.launcher.stores.download.DownloadQueue.clear(ctx, failedDownload.key) } } - item?.accessible == true && StoresState.isUnfinished(item) -> { + item?.installable == true && StoresState.isUnfinished(item) -> { InstallButton(stringResource(R.string.stores_resume_install), leadOn) { StoresState.requestInstall(ctx, item) } ConfirmButton(stringResource(R.string.stores_dl_clear), stringResource(R.string.stores_dl_cancel_confirm), compact = true) { StoresState.clearUnfinished(ctx, item) } } - item?.accessible == true -> InstallButton( - if (item.sizeBytes > 0) stringResource(R.string.stores_install_size, formatBytes(item.sizeBytes)) else stringResource(R.string.stores_install), - leadOn, - ) { StoresState.requestInstall(ctx, item) } + item?.installable == true -> { + InstallButton( + if (item.sizeBytes > 0) stringResource(R.string.stores_install_size, formatBytes(item.sizeBytes)) else stringResource(R.string.stores_install), + leadOn, + ) { StoresState.requestInstall(ctx, item) } + if (!item.accessible) { + SecondaryButton( + when { + item.isFree -> stringResource(R.string.stores_get_free) + item.hasPrice && item.finalPrice.isNotBlank() -> stringResource(R.string.stores_buy_price, item.finalPrice) + else -> stringResource(R.string.stores_view_on, store.shortLabel) + }, + ) { openStoreUrl(ctx, item) } + } + } item != null && item.isFree -> PrimaryButton(stringResource(R.string.stores_get_free), main = true, modifier = leadOn) { openStoreUrl(ctx, item) } item != null -> PrimaryButton(if (item.hasPrice && item.finalPrice.isNotBlank()) stringResource(R.string.stores_buy_price, item.finalPrice) else stringResource(R.string.stores_view_on, store.shortLabel), main = true, modifier = leadOn) { openStoreUrl(ctx, item) } } @@ -171,7 +186,7 @@ internal fun StoreGameDetail(store: Store, key: String, s: FrontEndState, a: Fro } if (StoresMotion.heroLands) hero() else Rise(1) { hero() } if (scores != null) Rise(2) { - val listed = StoresState.shelves[store]?.all.orEmpty().firstOrNull { it.id == id } + val listed = (StoresState.found[store].orEmpty() + StoresState.shelves[store]?.all.orEmpty()).firstOrNull { it.id == id } val developer = item?.developer?.ifBlank { null } ?: listed?.developer.orEmpty() val publisher = item?.publisher?.ifBlank { null } ?: listed?.publisher.orEmpty() val releaseDate = item?.releaseDate?.ifBlank { null } ?: listed?.releaseDate.orEmpty() diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoresDownloads.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoresDownloads.kt index 2c3a0090ef..2bf7dcac04 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoresDownloads.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoresDownloads.kt @@ -84,6 +84,7 @@ import androidx.compose.ui.unit.sp import com.droiddeck.launcher.R import com.droiddeck.launcher.session.SessionPrefs import com.droiddeck.launcher.stores.CatalogItem +import com.droiddeck.launcher.stores.StoreLanguage import com.droiddeck.launcher.stores.StoresState import com.droiddeck.launcher.stores.download.DownloadEntry import com.droiddeck.launcher.stores.download.DownloadQueue @@ -495,6 +496,7 @@ internal fun storesSettingsStep(at: Rect, s: androidx.compose.runtime.State + val options = listOf("") + StoreLanguage.KNOWN + options.forEachIndexed { i, code -> + MenuItem( + if (code.isEmpty()) stringResource(R.string.stores_install_language_system) else StoreLanguage.displayName(code), + checked = language == code, + focusRequester = if (i == 0) first else null, + ) { + language = code + SessionPrefs.setStoresInstallLanguage(context, code) + langOpen = false + } + } + } + } + } Column(Modifier.fillMaxWidth().padding(horizontal = 14.dp, vertical = 11.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { DownloadControls(st, a) } - val context = androidx.compose.ui.platform.LocalContext.current var gogAchievements by androidx.compose.runtime.remember { androidx.compose.runtime.mutableStateOf(com.droiddeck.launcher.stores.gog.GogComet.enabled(context)) } androidx.compose.runtime.LaunchedEffect(Unit) { if (gogAchievements) com.droiddeck.launcher.core.AddonPack.COMET.ensure(context) diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoresInstallDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoresInstallDialog.kt index 565b5cc9a1..662e8236fd 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoresInstallDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoresInstallDialog.kt @@ -25,7 +25,10 @@ import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip @@ -42,8 +45,12 @@ import com.droiddeck.launcher.R import com.droiddeck.launcher.session.SessionPrefs import com.droiddeck.launcher.stores.CatalogItem import com.droiddeck.launcher.stores.StoreInstallRoot +import com.droiddeck.launcher.stores.StoreLanguage import com.droiddeck.launcher.stores.StoresState import com.droiddeck.launcher.stores.formatBytes +import com.droiddeck.launcher.stores.gog.GogDownloadManager +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext @Composable internal fun InstallWhereDialog(item: CatalogItem, onDismiss: () -> Unit) { @@ -55,7 +62,19 @@ internal fun InstallWhereDialog(item: CatalogItem, onDismiss: () -> Unit) { val remembered = remember { SessionPrefs.storesInstallTarget(ctx) } val defaultIndex = targets.indexOfFirst { it.root.absolutePath == remembered }.coerceAtLeast(0) val focus = remember { List(targets.size) { FocusRequester() } } + val askLanguage = StoreLanguage.selectable(item.store) + val preferredLanguage = StoreLanguage.preferredCode(ctx) + var languages by remember { mutableStateOf(StoreLanguage.fallbackList(item.store)) } + var chosen by remember(preferredLanguage) { mutableStateOf(StoreLanguage.pick(languages, preferredLanguage)) } + var menuOpen by remember { mutableStateOf(false) } LaunchedEffect(Unit) { focusWithinFrames({ false }) { focus[defaultIndex] } } + LaunchedEffect(item.key) { + if (item.store != com.droiddeck.launcher.stores.Store.GOG) return@LaunchedEffect + val listed = withContext(Dispatchers.IO) { GogDownloadManager.listLanguages(ctx, item.id) } + if (listed.isEmpty()) return@LaunchedEffect + languages = listed + chosen = StoreLanguage.pick(listed, chosen) + } AppDialog(shown, close, "installWhere", wide = false, maxWidth = if (targets.size > 2) 600.dp else 440.dp) { Rise(0) { Row(verticalAlignment = Alignment.CenterVertically, modifier = Modifier.fillMaxWidth()) { @@ -65,11 +84,27 @@ internal fun InstallWhereDialog(item: CatalogItem, onDismiss: () -> Unit) { ) Text( stringResource(R.string.common_cancel), fontSize = 13.sp, fontWeight = FontWeight.SemiBold, color = colors.onSurfaceVariant, - modifier = Modifier.clip(Shape12).clickable(role = Role.Button, onClick = close).padding(horizontal = 10.dp, vertical = 6.dp), + modifier = Modifier.clip(Shape12).clickable(role = Role.Button, onClick = close).controllerConfirm(onClick = close).padding(horizontal = 10.dp, vertical = 6.dp), ) } } - Rise(1) { + if (askLanguage) Rise(1) { + Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp), modifier = Modifier.fillMaxWidth()) { + Text(stringResource(R.string.stores_install_language), fontSize = 13.sp, color = colors.onSurfaceVariant) + Box(Modifier.weight(1f)) { + ValueChip(StoreLanguage.displayName(chosen).ifEmpty { chosen }, menuOpen, modifier = Modifier.fillMaxWidth()) { menuOpen = !menuOpen } + AnchoredMenu(menuOpen, { menuOpen = false }, title = stringResource(R.string.stores_install_language), compact = true) { first -> + languages.forEachIndexed { i, code -> + MenuItem(StoreLanguage.displayName(code).ifEmpty { code }, checked = code == chosen, focusRequester = if (i == 0) first else null) { + chosen = code + menuOpen = false + } + } + } + } + } + } + Rise(if (askLanguage) 2 else 1) { Row(horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.fillMaxWidth()) { targets.forEachIndexed { i, t -> val needed = com.droiddeck.launcher.stores.StoreInstallRoot.estimatedBytesNeeded(item) @@ -89,7 +124,7 @@ internal fun InstallWhereDialog(item: CatalogItem, onDismiss: () -> Unit) { warning = isLow, modifier = Modifier.weight(1f), ) { SessionPrefs.setStoresInstallTarget(ctx, t.root.absolutePath) - StoresState.install(ctx, item, t.root) + StoresState.install(ctx, item, t.root, if (askLanguage) chosen else null) close() } } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt index 4251212203..182f3a1d52 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt @@ -30,6 +30,7 @@ import androidx.compose.ui.layout.boundsInParent import androidx.compose.ui.layout.boundsInRoot import androidx.compose.ui.layout.positionInRoot import com.droiddeck.launcher.stores.StoreInstallRoot +import com.droiddeck.launcher.stores.StoreLanguage import com.droiddeck.launcher.stores.epic.EpicClient import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.delay @@ -201,12 +202,12 @@ internal fun StoresPage(s: FrontEndState, a: FrontEndActions, modifier: Modifier val colors = MaterialTheme.colorScheme val narrow = LocalNarrowPane.current val padH = if (narrow) 14.dp else 22.dp - var chip by rememberSaveable { mutableStateOf(Store.GOG.id) } val tabs = remember { androidx.compose.runtime.mutableStateListOf().apply { addAll(arrangeStoreTabs(SessionPrefs.storesTabOrder(ctx), SessionPrefs.storesTabHidden(ctx))) } } + var chip by rememberSaveable { mutableStateOf(tabs.firstOrNull { it.shown }?.store?.id ?: Store.GOG.id) } var arranging by remember { mutableStateOf(false) } val shownStores = tabs.filter { it.shown }.map { it.store } fun commitTabs() { @@ -543,7 +544,10 @@ private fun InstallWhere(item: CatalogItem) { val ctx = LocalContext.current val pal = LocalPalette.current val from = remember(item) { StoresMotion.recentInstall() } - if (from == null) { InstallWhereDialog(item) { StoresState.pendingInstall = null }; return } + if (from == null || StoreLanguage.selectable(item.store)) { + InstallWhereDialog(item) { StoresState.pendingInstall = null } + return + } val title = stringResource(R.string.stores_install_title, item.title) val internalLabel = stringResource(R.string.stores_target_internal) val label = StoresMotion.installLabel @@ -638,8 +642,9 @@ private fun StoreDot(store: Store, signedIn: Boolean) { Box( Modifier.size(12.dp) .onGloballyPositioned { StoresMotion.dots[store] = it.boundsInRoot() } - .pulseRing(StoresMotion.pulses[store] ?: 0, c.dot), - ) { Box(Modifier.matchParentSize().clip(CircleShape).background(c.dot).alpha(if (signedIn) 1f else 0.35f)) } + .pulseRing(StoresMotion.pulses[store] ?: 0, c.dot) + .background(c.dot.copy(alpha = if (signedIn) 1f else 0.35f), CircleShape), + ) } @Composable @@ -1006,8 +1011,11 @@ private fun Storefront( val density = androidx.compose.ui.platform.LocalDensity.current val focus = LocalFrontFocus.current val scope = rememberCoroutineScope() - val headerItems = 1 + (if (sizeSortPending) 1 else 0) + - (if (StoresState.status[store] != null) 1 else 0) + (if (StoresState.problems[store] != null) 1 else 0) + // A bar only where the tab has nothing else on it: shelves, the shelf of owned games, or a grid still loading. + val gridEmpty = if (showGrid) visible.isEmpty() else (shelves == null || shelves.isEmpty) && library.isEmpty() + val barLine = StoresState.status[store]?.takeIf { gridEmpty && syncCount(it) != null } + val headerItems = 1 + (if (sizeSortPending) 1 else 0) + (if (barLine != null) 1 else 0) + + (if (StoresState.problems[store] != null) 1 else 0) val listMode = s.storesView == "list" && tab == "library" val capsules = s.storesView == "capsules" && tab == "library" val tileWidth = if (capsules) CapsuleWidth else CardWidth @@ -1090,7 +1098,7 @@ private fun Storefront( Text(stringResource(R.string.store_section_loading), fontSize = 11.sp, color = MaterialTheme.colorScheme.onSurfaceVariant) } } - StoresState.status[store]?.let { line -> item(key = "sync", span = { GridItemSpan(maxLineSpan) }) { Rise(3) { SyncBar(line) } } } + barLine?.let { line -> item(key = "sync", span = { GridItemSpan(maxLineSpan) }) { Rise(3) { SyncBar(line) } } } StoresState.problems[store]?.let { line -> item(key = "problem", span = { GridItemSpan(maxLineSpan) }) { Rise(3) { Box(Modifier.padding(bottom = 8.dp)) { Note(line) } } } } when (tab) { "library" -> if (!loaded) Unit @@ -1479,22 +1487,35 @@ private fun GameCard( } } +private fun syncCount(line: String): Pair? { + val match = Regex("(\\d+)\\s*/\\s*(\\d+)").find(line) ?: return null + val done = match.groupValues[1].toIntOrNull() ?: return null + val total = match.groupValues[2].toIntOrNull()?.takeIf { it > 0 } ?: return null + return done to total +} + @Composable private fun SyncBar(line: String) { - val count = Regex("(\\d+)\\s*/\\s*(\\d+)").find(line) - val done = count?.groupValues?.get(1)?.toIntOrNull() - val total = count?.groupValues?.get(2)?.toIntOrNull()?.takeIf { it > 0 } + val count = syncCount(line) ?: return + val done = count.first + val total = count.second Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.fillMaxWidth().padding(bottom = 8.dp)) { - Box(Modifier.weight(1f)) { - if (done != null && total != null) androidx.compose.material3.LinearProgressIndicator(progress = { (done.toFloat() / total).coerceIn(0f, 1f) }, modifier = Modifier.fillMaxWidth().height(3.dp)) - else androidx.compose.material3.LinearProgressIndicator(modifier = Modifier.fillMaxWidth().height(3.dp)) - } - if (done != null && total != null) Text("$done/$total", fontSize = 11.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 1) + Box(Modifier.weight(1f)) { androidx.compose.material3.LinearProgressIndicator(progress = { (done.toFloat() / total).coerceIn(0f, 1f) }, modifier = Modifier.fillMaxWidth().height(3.dp)) } + Text("$done/$total", fontSize = 11.sp, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 1) } } private val CardStrip = 26.dp +@Composable +internal fun cardArtRequest(url: String?, cover: String?): coil.request.ImageRequest? { + val ctx = LocalContext.current + val under = cover?.takeIf { it != url } + return remember(url, under) { + url?.let { coil.request.ImageRequest.Builder(ctx).data(it).apply { if (under != null) placeholderMemoryCacheKey(under) }.build() } + } +} + @OptIn(androidx.compose.foundation.ExperimentalFoundationApi::class) @Composable private fun CardFace( @@ -1502,26 +1523,27 @@ private fun CardFace( marker: @Composable () -> Unit, ) { val url = if (capsule) item.tallImageUrl ?: item.imageUrl else item.imageUrl ?: item.tallImageUrl + val art = cardArtRequest(url, item.tallImageUrl) val blurs = android.os.Build.VERSION.SDK_INT >= 31 var landscape by remember(url) { mutableStateOf(false) } BoxWithConstraints(Modifier.fillMaxWidth()) { val total = if (capsule) maxWidth * 7f / 5f + CardStrip else maxWidth * 9f / 16f + CardStrip Box(Modifier.fillMaxWidth().height(total).background(Color(0xFF101318)).then(if (url == null) Modifier.background(artBrush(hueOf(item.title))) else Modifier)) { - if (url != null && capsule && landscape) { + if (art != null && capsule && landscape) { // Stores without portrait covers (itch) would lose most of the art to a portrait crop. - AsyncImage(model = url, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize().blur(24.dp)) + AsyncImage(model = art, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize().blur(24.dp)) Spacer(Modifier.matchParentSize().background(Color.Black.copy(alpha = if (blurs) 0.35f else 0.7f))) - AsyncImage(model = url, contentDescription = null, contentScale = ContentScale.Fit, modifier = Modifier.matchParentSize().padding(bottom = CardStrip)) - } else if (url != null) AsyncImage( - model = url, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize(), + AsyncImage(model = art, contentDescription = null, contentScale = ContentScale.Fit, modifier = Modifier.matchParentSize().padding(bottom = CardStrip)) + } else if (art != null) AsyncImage( + model = art, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize(), onSuccess = { r -> - val art = r.result.drawable - if (capsule && art.intrinsicWidth > 0 && art.intrinsicHeight > 0) landscape = art.intrinsicWidth > art.intrinsicHeight * 0.95f + val drawn = r.result.drawable + if (capsule && drawn.intrinsicWidth > 0 && drawn.intrinsicHeight > 0) landscape = drawn.intrinsicWidth > drawn.intrinsicHeight * 0.95f }, ) Box(Modifier.align(Alignment.BottomCenter).fillMaxWidth().height(CardStrip).clipToBounds()) { - if (url != null) AsyncImage( - model = url, contentDescription = null, contentScale = ContentScale.Crop, + if (art != null) AsyncImage( + model = art, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.fillMaxWidth().wrapContentHeight(Alignment.Bottom, unbounded = true).height(total).blur(24.dp), ) Spacer(Modifier.matchParentSize().background(Color.Black.copy(alpha = if (blurs) 0.45f else 0.7f))) @@ -1574,9 +1596,10 @@ private fun CardMarker(item: CatalogItem, installed: Boolean, download: com.droi @Composable internal fun CardArt(item: CatalogItem, modifier: Modifier) { val url = item.imageUrl ?: item.tallImageUrl + val art = cardArtRequest(url, item.tallImageUrl) val colors = MaterialTheme.colorScheme Box(modifier.background(colors.surfaceVariant).then(if (url == null) Modifier.background(artBrush(hueOf(item.title))) else Modifier)) { - if (url != null) AsyncImage(model = url, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize()) + if (art != null) AsyncImage(model = art, contentDescription = null, contentScale = ContentScale.Crop, modifier = Modifier.matchParentSize()) else Text(item.title, fontSize = 10.sp, fontWeight = FontWeight.Black, color = Color.White, maxLines = 3, overflow = TextOverflow.Ellipsis, modifier = Modifier.align(Alignment.BottomStart).padding(6.dp)) Spacer(Modifier.matchParentSize().background(androidx.compose.ui.graphics.Brush.verticalGradient(0.6f to Color.Transparent, 1f to colors.surface.copy(alpha = 0.85f)))) } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/TouchGestureDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/TouchGestureDialog.kt index 8cd79257d6..db975a1996 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/TouchGestureDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/TouchGestureDialog.kt @@ -69,7 +69,7 @@ fun TouchGestureDialog(game: String?, onDismiss: () -> Unit, onSaved: () -> Unit val actions = mouse + ACTION_SHOW_KEYBOARD + GestureKeys.codes.keys.map { "key_$it" } + ACTION_KEY_TILDE val p = LocalPalette.current - GestureDialogFrame(stringResource(R.string.gesture_settings), stringResource(R.string.gesture_editor_subtitle), onDismiss, + GestureDialogFrame(onDismiss, footer = { Row(Modifier.fillMaxWidth().padding(horizontal = 20.dp, vertical = 12.dp), horizontalArrangement = Arrangement.End, verticalAlignment = Alignment.CenterVertically) { TextButton(onClick = onDismiss) { Text(stringResource(R.string.gesture_cancel)) } @@ -83,15 +83,6 @@ fun TouchGestureDialog(game: String?, onDismiss: () -> Unit, onSaved: () -> Unit }, modifier = Modifier.testTag("gesture-save")) { Text(stringResource(R.string.gesture_save_changes)) } } }) { - Column(Modifier.padding(horizontal = 20.dp)) { - Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) { - GestureFilterChip(!forGame, onClick = { forGame = false }, label = { Text(stringResource(R.string.gesture_defaults)) }, modifier = Modifier.testTag("gesture-scope-default")) - if (targetGame != null) GestureFilterChip(forGame, onClick = { forGame = true }, label = { Text(stringResource(R.string.gesture_game)) }, modifier = Modifier.testTag("gesture-scope-game")) - if (forGame && gameDraft != null) TextButton(onClick = { gameDraft = null }, modifier = Modifier.testTag("gesture-inherit")) { Text(stringResource(R.string.gesture_use_defaults)) } - } - Text(stringResource(if (!forGame) R.string.gesture_scope_default else if (gameDraft == null) R.string.gesture_inheriting else R.string.gesture_scope_game), - color = p.onSurfaceVariant, style = MaterialTheme.typography.bodySmall, modifier = Modifier.padding(bottom = 12.dp)) - } ScrollableTabRow(tab, edgePadding = 12.dp, containerColor = p.surface, divider = { HorizontalDivider(color = p.line) }) { tabs.forEachIndexed { index, title -> Tab(tab == index, onClick = { tab = index }, text = { Text(stringResource(title)) }, selectedContentColor = p.onBackground, @@ -100,9 +91,16 @@ fun TouchGestureDialog(game: String?, onDismiss: () -> Unit, onSaved: () -> Unit } key(tab) { Column(Modifier.weight(1f).fillMaxWidth().verticalScroll(rememberScrollState()).padding(20.dp), verticalArrangement = Arrangement.spacedBy(14.dp)) { + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) { + GestureFilterChip(!forGame, onClick = { forGame = false }, label = { Text(stringResource(R.string.gesture_defaults)) }, modifier = Modifier.testTag("gesture-scope-default")) + if (targetGame != null) GestureFilterChip(forGame, onClick = { forGame = true }, label = { Text(stringResource(R.string.gesture_game)) }, modifier = Modifier.testTag("gesture-scope-game")) + } + if (forGame && gameDraft != null) TextButton(onClick = { gameDraft = null }, modifier = Modifier.testTag("gesture-inherit")) { Text(stringResource(R.string.gesture_use_defaults)) } + } when (tab) { 0 -> { - GestureSection(R.string.gesture_tab_one, R.string.gesture_one_hint) + GestureSection(R.string.gesture_tab_one) GestureCard(R.string.gesture_tap, config.tapEnabled, { change(config.copy(tapEnabled = it)) }) { GestureActionField("tap", R.string.gesture_tap, config.tapAction, actions) { change(config.copy(tapAction = it)) } } @@ -118,7 +116,7 @@ fun TouchGestureDialog(game: String?, onDismiss: () -> Unit, onSaved: () -> Unit } } 1 -> { - GestureSection(R.string.gesture_tab_two, R.string.gesture_two_hint) + GestureSection(R.string.gesture_tab_two) GestureCard(R.string.gesture_two_tap, config.twoFingerTapEnabled, { change(config.copy(twoFingerTapEnabled = it)) }) { GestureActionField("two-tap", R.string.gesture_two_tap, config.twoFingerTapAction, actions) { change(config.copy(twoFingerTapAction = it)) } } @@ -134,7 +132,7 @@ fun TouchGestureDialog(game: String?, onDismiss: () -> Unit, onSaved: () -> Unit } } 2 -> { - GestureSection(R.string.gesture_tab_three, R.string.gesture_three_hint) + GestureSection(R.string.gesture_tab_three) GestureCard(R.string.gesture_three_tap, config.threeFingerTapEnabled, { change(config.copy(threeFingerTapEnabled = it)) }) { GestureActionField("three-tap", R.string.gesture_three_tap, config.threeFingerTapAction, actions) { change(config.copy(threeFingerTapAction = it)) } } @@ -147,16 +145,13 @@ fun TouchGestureDialog(game: String?, onDismiss: () -> Unit, onSaved: () -> Unit } } 3 -> { - GestureSection(R.string.gesture_tab_options, R.string.gesture_options_hint) + GestureSection(R.string.gesture_tab_options) GestureSettingsCard(R.string.gesture_movement) { - Text(stringResource(R.string.gesture_movement_hint), color = p.onSurfaceVariant, style = MaterialTheme.typography.bodyMedium) GestureChoiceChips(config.mouseDragMovementMode, listOf(MOUSE_DRAG_MOVEMENT_DIRECT to stringResource(R.string.gesture_direct), MOUSE_DRAG_MOVEMENT_RELATIVE to stringResource(R.string.gesture_relative))) { change(config.copy(mouseDragMovementMode = it)) } - Text(stringResource(R.string.gesture_middle_relative_hint), color = p.onSurfaceVariant, style = MaterialTheme.typography.bodySmall) } GestureSettingsCard(R.string.gesture_recognition) { Text(stringResource(R.string.gesture_threshold, config.gestureThreshold), style = MaterialTheme.typography.bodyMedium) Slider(config.gestureThreshold.toFloat(), { change(config.copy(gestureThreshold = it.toInt())) }, valueRange = 10f..100f, steps = 17) - Text(stringResource(R.string.gesture_threshold_hint), color = p.onSurfaceVariant, style = MaterialTheme.typography.bodySmall) } GestureSettingsCard(R.string.gesture_feedback) { GestureToggle(R.string.gesture_debug, config.showGestureDebugOverlay) { change(config.copy(showGestureDebugOverlay = it)) } @@ -170,7 +165,7 @@ fun TouchGestureDialog(game: String?, onDismiss: () -> Unit, onSaved: () -> Unit } @Composable -private fun GestureDialogFrame(title: String, subtitle: String, onDismiss: () -> Unit, +private fun GestureDialogFrame(onDismiss: () -> Unit, footer: @Composable () -> Unit = {}, content: @Composable ColumnScope.() -> Unit) { val p = LocalPalette.current // The app window does not opt into RTL, so these dialogs follow their resource locale explicitly. @@ -181,15 +176,8 @@ private fun GestureDialogFrame(title: String, subtitle: String, onDismiss: () -> Surface(Modifier.widthIn(max = 1040.dp).fillMaxWidth().fillMaxHeight(), shape = RoundedCornerShape(22.dp), color = p.background, contentColor = p.onBackground, border = BorderStroke(1.dp, p.line2)) { Column { - Row(Modifier.fillMaxWidth().padding(start = 20.dp, end = 8.dp, top = 14.dp, bottom = 12.dp), verticalAlignment = Alignment.CenterVertically) { - Surface(shape = RoundedCornerShape(12.dp), color = p.primary.copy(alpha = 0.14f)) { - Icon(Icons.Default.TouchApp, null, tint = p.primary, modifier = Modifier.padding(10.dp).size(24.dp)) - } - Column(Modifier.weight(1f).padding(horizontal = 14.dp), verticalArrangement = Arrangement.spacedBy(3.dp)) { - Text(title, style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.SemiBold) - Text(subtitle, style = MaterialTheme.typography.bodySmall, color = p.onSurfaceVariant) - } - IconButton(onClick = onDismiss) { Icon(Icons.Default.Close, stringResource(R.string.gesture_close)) } + Row(Modifier.fillMaxWidth().padding(end = 4.dp), horizontalArrangement = Arrangement.End) { + IconButton(onClick = onDismiss, modifier = Modifier.size(40.dp)) { Icon(Icons.Default.Close, stringResource(R.string.gesture_close)) } } content() HorizontalDivider(color = p.line) @@ -202,11 +190,8 @@ private fun GestureDialogFrame(title: String, subtitle: String, onDismiss: () -> } @Composable -private fun GestureSection(@StringRes title: Int, @StringRes hint: Int) { - Column(verticalArrangement = Arrangement.spacedBy(4.dp)) { - Text(stringResource(title), style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.SemiBold) - Text(stringResource(hint), style = MaterialTheme.typography.bodyMedium, color = LocalPalette.current.onSurfaceVariant) - } +private fun GestureSection(@StringRes title: Int) { + Text(stringResource(title), style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.SemiBold) } @Composable @@ -242,18 +227,18 @@ private fun GestureActionField(id: String, @StringRes gesture: Int, selected: St Icon(Icons.AutoMirrored.Filled.ArrowForward, null, modifier = Modifier.size(19.dp), tint = p.onSurfaceVariant) } } - if (open) GestureActionPicker(choices, selected, stringResource(gesture), onDismiss = { open = false }) { open = false; onChoose(it) } + if (open) GestureActionPicker(choices, selected, onDismiss = { open = false }) { open = false; onChoose(it) } } @Composable -internal fun GestureActionPicker(choices: List, selected: String, gesture: String, onDismiss: () -> Unit, onChoose: (String) -> Unit) { +internal fun GestureActionPicker(choices: List, selected: String, onDismiss: () -> Unit, onChoose: (String) -> Unit) { var query by rememberSaveable { mutableStateOf("") } var category by remember { mutableStateOf(null) } val catalog = choices.distinct().map { GestureAction(it, gestureActionTitle(it), gestureActionGroup(it)) } val groups = GestureActionGroup.entries.filter { group -> catalog.any { it.group == group } } val shown = filterGestureActions(catalog, query, category) val p = LocalPalette.current - GestureDialogFrame(stringResource(R.string.gesture_action), stringResource(R.string.gesture_action_for, gesture), onDismiss) { + GestureDialogFrame(onDismiss) { OutlinedTextField(query, onValueChange = { query = it }, modifier = Modifier.fillMaxWidth().padding(horizontal = 20.dp).testTag("gesture-action-search"), singleLine = true, shape = RoundedCornerShape(12.dp), placeholder = { Text(stringResource(R.string.gesture_search_actions)) }, leadingIcon = { Icon(Icons.Default.Search, null) }, trailingIcon = { diff --git a/app/src/main/java/com/droiddeck/launcher/update/SelfInstaller.kt b/app/src/main/java/com/droiddeck/launcher/update/SelfInstaller.kt index 581606f7cf..4ba3a20cc4 100644 --- a/app/src/main/java/com/droiddeck/launcher/update/SelfInstaller.kt +++ b/app/src/main/java/com/droiddeck/launcher/update/SelfInstaller.kt @@ -57,7 +57,8 @@ object SelfInstaller { } @Suppress("DEPRECATION") val flags = if (Build.VERSION.SDK_INT >= 28) { - PackageManager.GET_SIGNING_CERTIFICATES + // Android 9 and 10 only collect an archive's certificates when GET_SIGNATURES is set. + PackageManager.GET_SIGNING_CERTIFICATES or PackageManager.GET_SIGNATURES } else { PackageManager.GET_SIGNATURES } @@ -75,15 +76,18 @@ object SelfInstaller { throw IOException(context.getString(R.string.selfinst_downgrade, code, BuildConfig.VERSION_CODE)) } - if (Build.VERSION.SDK_INT >= 28) { - val signing = info.signingInfo ?: throw IOException(context.getString(R.string.selfinst_no_signing)) - val digests = signing.apkContentsSigners.orEmpty().map { cert -> - MessageDigest.getInstance("SHA-256").digest(cert.toByteArray()) - .joinToString("") { "%02x".format(it) } - } - if (digests.none { it.equals(BuildConfig.RELEASE_SIGNER, ignoreCase = true) }) { - throw IOException(context.getString(R.string.selfinst_wrong_signer)) - } + val digests = archiveSignerDigests(info) + if (digests.isEmpty()) throw IOException(context.getString(R.string.selfinst_no_signing)) + if (digests.none { it.equals(BuildConfig.RELEASE_SIGNER, ignoreCase = true) }) { + throw IOException(context.getString(R.string.selfinst_wrong_signer)) + } + } + + @Suppress("DEPRECATION") + internal fun archiveSignerDigests(info: android.content.pm.PackageInfo): List { + val certs = (if (Build.VERSION.SDK_INT >= 28) info.signingInfo?.apkContentsSigners else null) ?: info.signatures + return certs.orEmpty().map { cert -> + MessageDigest.getInstance("SHA-256").digest(cert.toByteArray()).joinToString("") { "%02x".format(it) } } } diff --git a/app/src/main/res/values-ar/gestures.xml b/app/src/main/res/values-ar/gestures.xml index 5aee4b085d..6e4aa54682 100644 --- a/app/src/main/res/values-ar/gestures.xml +++ b/app/src/main/res/values-ar/gestures.xml @@ -18,8 +18,6 @@ النقر مرة واحدة مهلة الضغط المستمر الفاصل بين النقرتين - ينطبق على اللعبة الحالية - الإعدادات الافتراضية لجميع الألعاب استعادة إعدادات الإيماءات الأصلية إلغاء اختيار إجراء @@ -37,23 +35,16 @@ عجلة الفأرة عتبة الإيماءات: %1$d بكسل إظهار الإيماءة المكتشفة - عناصر تحكم الفأرة ولوحة المفاتيح مرتبة حسب الإيماءة إصبع واحد إصبعان ثلاثة أصابع خيارات - اختر إجراء النقر أو السحب أو الضغط المستمر. - اضبط تحريك الكاميرا والتكبير والنقرات الثانوية. - اجعل الاختصارات الإضافية في متناولك. - اضبط الحركة والتعرّف والاستجابة المرئية. الافتراضية هذه اللعبة استخدام الإعدادات الافتراضية - تُستخدم الإعدادات الافتراضية. يؤدي التعديل إلى إنشاء إعدادات خاصة باللعبة. حفظ التغييرات إغلاق الإجراء - لـ %1$s البحث عن إجراءات الفأرة أو مفاتيح لوحة المفاتيح مسح البحث الكل @@ -68,12 +59,9 @@ لوحة الأرقام الرموز حركة الفأرة - يتبع السحب المباشر موضع اللمس. ويتبع السحب النسبي حركة الإصبع، وهو مفيد عندما تعيد اللعبة الفأرة إلى المنتصف. - يتبع تحريك العرض بالزر الأوسط حركة الإصبع دائمًا لتجنّب قفزات المؤشر. مباشر نسبي التعرّف على الإيماءات - تحرّك هذه المسافة قبل أن تتحول إيماءة بإصبعين أو ثلاثة إلى تحريك العرض أو التكبير. الاستجابة المرئية سلوك زر الفأرة %1$d مللي ثانية diff --git a/app/src/main/res/values-ar/strings.xml b/app/src/main/res/values-ar/strings.xml index c8fd949fbe..8002743d4f 100644 --- a/app/src/main/res/values-ar/strings.xml +++ b/app/src/main/res/values-ar/strings.xml @@ -512,7 +512,9 @@ هل تريد حذف هذه النسخة الأصلية؟ هذه النسخة الأصلية من %1$s تعود إلى إصدار سابق من %2$s. يتم دائمًا الاحتفاظ بالنسخة الأصلية للإصدار الحالي. في الإصدارات الليلية · %1$d - حدّث لعرض الحزم في الإصدارات الليلية. + مستقر + ليلي + حدّث لعرض الحزم في إصدارات Nightlies وDroidDeck. لا جديد منذ آخر فحص. استيراد ملف ‎.wcp استعادة النسخة الأصلية لـ Proton هذا @@ -590,6 +592,16 @@ الصفحة السابقة الصفحة التالية واجهة الأداء + معدل الإطارات + درجة حرارة البطارية + مخطط الأداء + اللون + نعناعي + أبيض + سماوي + كهرماني + بنفسجي + العتامة وضع التحجيم حدة التحجيم مؤثرات الشاشة @@ -1854,7 +1866,8 @@ تم الاحتفاظ بأصل النسخة المثبَّتة: فهو طريق العودة. غير مخزَّن تم حذف أصل %2$s من %1$s. - التنزيلات تأتي فقط من إصدارات Nightlies + التنزيلات تأتي فقط من إصدارات Nightlies وDroidDeck + فشل التنزيل: ربما استُبدل هذا الإصدار الليلي بإصدار أحدث. حدّث القائمة وحاول مرة أخرى. قائمة الحزم هذه أقدم من إضافة المجاميع الاختبارية - حدِّثها وحاوِل مرة أخرى عدم تطابق المجموع الاختباري @@ -2110,6 +2123,9 @@ آخر مزامنة %1$s لم تتم المزامنة بعد %1$d ملفات + محدَّث بالفعل + سجّل الدخول إلى المتجر لمزامنة الحفظ + لم تتم مزامنة الحفظ مثبَّتة في مكتبتك متجر @@ -2421,7 +2437,7 @@ تم تعذّر حفظ تخطيط اللمس تم حفظ تخطيط اللمس في Steam - التطبيق %1$d + التطبيق %1$s التسمية (اختياري) لم يتم العثور على أيقونات Steam @@ -2520,6 +2536,15 @@ مجال رؤية SteamVR القيمة الأقل تقرّب SteamVR وتملأ النظارة؛ والأعلى تُظهر المزيد مما حولك. جارٍ اللعب على %1$s + إعادة التوسيط + قائمة SteamVR + العصي: اليدان ⇄ اللعبة + وحدات التحكم: %1$s + لوحة المفاتيح + قائمة الجلسة + إيقاف SteamVR + السطوع %1$d / %2$d + البطارية %1$d%% · %2$d °C معايرة التتبّع يقلّل الانجراف ويضبط المرجع الأفقي. تُطبَّق المعايرة المحفوظة على هذه النظارة. diff --git a/app/src/main/res/values-b+es+419/gestures.xml b/app/src/main/res/values-b+es+419/gestures.xml index 13a89a1b84..4f5f49779b 100644 --- a/app/src/main/res/values-b+es+419/gestures.xml +++ b/app/src/main/res/values-b+es+419/gestures.xml @@ -18,8 +18,6 @@ Hacer clic una vez Tiempo de pulsación sostenida Intervalo de doble toque - Se aplica al juego actual - Ajustes predeterminados para todos los juegos Restablecer los ajustes originales de gestos Cancelar Elegir acción @@ -37,23 +35,16 @@ Rueda del ratón Umbral de gestos: %1$d px Mostrar gesto reconocido - Controles de ratón y teclado organizados por gesto Un dedo Dos dedos Tres dedos Opciones - Elige qué debe hacer un toque, arrastre o pulsación sostenida. - Configura el movimiento de cámara, el zoom y los clics secundarios. - Ten más accesos directos al alcance de la mano. - Ajusta el movimiento, el reconocimiento y la respuesta visual. Predeterminados Este juego Usar valores predeterminados - Se usan los ajustes predeterminados. Al editarlos, se crean ajustes específicos del juego. Guardar cambios Cerrar ACCIÓN - Para %1$s Buscar acciones de ratón o teclas del teclado Borrar búsqueda Todas @@ -68,12 +59,9 @@ Teclado numérico Símbolos Movimiento del ratón - El arrastre directo sigue la posición del toque. El relativo sigue el movimiento del dedo y resulta útil cuando un juego centra el ratón. - El desplazamiento con el botón central siempre sigue el movimiento del dedo para evitar saltos del cursor. Directo Relativo Reconocimiento de gestos - Recorre esta distancia antes de que un gesto con dos o tres dedos se convierta en desplazamiento o zoom. Respuesta visual Comportamiento del botón del ratón %1$d ms diff --git a/app/src/main/res/values-b+es+419/strings.xml b/app/src/main/res/values-b+es+419/strings.xml index a9303902af..fb9b4c3c93 100644 --- a/app/src/main/res/values-b+es+419/strings.xml +++ b/app/src/main/res/values-b+es+419/strings.xml @@ -499,7 +499,9 @@ ¿Eliminar este original? Este original de %1$s es de una versión anterior de %2$s. El original de la versión actual siempre se conserva. En las Nightlies · %1$d - Actualiza para listar los paquetes de las Nightlies. + Estable + Nocturna + Actualiza para listar los paquetes de Nightlies y DroidDeck. Nada nuevo desde la última comprobación. Importar .wcp Restaurar el original de este Proton @@ -577,6 +579,16 @@ Página anterior Página siguiente HUD de rendimiento + Tasa de fotogramas + Temperatura de la batería + Gráfico de rendimiento + Color + Menta + Blanco + Celeste + Ámbar + Violeta + Opacidad Modo de escalado Nitidez del escalado Efectos de pantalla @@ -1830,7 +1842,8 @@ El original de la versión instalada se conserva: es el camino de vuelta. No guardado Se eliminó el original de %1$s de %2$s. - Las descargas solo proceden de las versiones Nightlies + Las descargas solo proceden de las versiones de Nightlies y DroidDeck + Falló la descarga: es posible que esta compilación nocturna se haya reemplazado por una más nueva. Actualiza la lista e inténtalo de nuevo. Esta lista de paquetes es anterior a las sumas de verificación - actualízala e inténtalo de nuevo La suma de verificación no coincide Lineal @@ -2053,6 +2066,9 @@ Última sincronización %1$s Aún sin sincronizar %1$d archivos + Ya está al día + Inicia sesión en la tienda para sincronizar las partidas + No se sincronizaron las partidas instalado en tu biblioteca tienda @@ -2458,6 +2474,15 @@ Campo de visión de SteamVR Más bajo acerca SteamVR y llena las gafas; más alto muestra más a tu alrededor. Jugando en %1$s + Recentrar + Menú de SteamVR + Sticks: manos ⇄ juego + Controles: %1$s + Teclado + Menú de sesión + Detener SteamVR + Brillo %1$d / %2$d + Batería %1$d%% · %2$d °C Calibración del seguimiento Reduce la deriva y alinea la referencia horizontal. Estas gafas usan la calibración guardada. diff --git a/app/src/main/res/values-bg/gestures.xml b/app/src/main/res/values-bg/gestures.xml index 4c389aaba6..7c05b9b60e 100644 --- a/app/src/main/res/values-bg/gestures.xml +++ b/app/src/main/res/values-bg/gestures.xml @@ -18,8 +18,6 @@ Еднократно щракване Закъснение за задържане Интервал за двойно докосване - Прилага се към текущата игра - Настройки по подразбиране за всички игри Възстановяване на първоначалните настройки на жестовете Отказ Избор на действие @@ -37,23 +35,16 @@ Колелце на мишката Праг на жестовете: %1$d пиксела Показване на разпознатия жест - Управление с мишка и клавиатура, подредено по жестове Един пръст Два пръста Три пръста Опции - Изберете действието при докосване, плъзгане или задържане. - Настройте преместването на камерата, мащабирането и вторичните щраквания. - Дръжте допълнителните команди подръка. - Настройте движението, разпознаването и визуалната обратна връзка. Стандартни настройки Тази игра Използване на подразбиращите се - Използват се настройките по подразбиране. Редактирането създава настройки за тази игра. Запазване на промените Затвори ДЕЙСТВИЕ - За %1$s Търсене на действия с мишката или клавиши Изчистване на търсенето Всички @@ -68,12 +59,9 @@ Цифрова клавиатура Символи Движение на мишката - Директното плъзгане следва мястото на докосване. Относителното следва движението на пръста и е полезно, когато играта центрира мишката. - Преместването със средния бутон винаги следва движението на пръста, за да няма скокове на курсора. Директно Относително Разпознаване на жестове - Изминете това разстояние, преди жест с два или три пръста да стане преместване или мащабиране. Визуална обратна връзка Поведение на бутона на мишката %1$d мс diff --git a/app/src/main/res/values-bg/strings.xml b/app/src/main/res/values-bg/strings.xml index aba51d5590..52c09a0152 100644 --- a/app/src/main/res/values-bg/strings.xml +++ b/app/src/main/res/values-bg/strings.xml @@ -504,7 +504,9 @@ Изтриване на този оригинал? Този оригинал на %1$s е от по-стара версия на %2$s. Оригиналът на текущата версия винаги се запазва. В Nightlies · %1$d - Обновете, за да видите пакетите в Nightlies. + Стабилна + Нощна + Обновете, за да видите пакетите в Nightlies и DroidDeck. Нищо ново от последната проверка. Импортиране на .wcp Възстановяване на оригинала на този Proton @@ -582,6 +584,16 @@ Предишна страница Следваща страница HUD за производителност + Честота на кадрите + Температура на батерията + Графика на производителността + Цвят + Мента + Бяло + Небесно + Кехлибарено + Виолетово + Прозрачност Режим на мащабиране Острота на мащабиране Ефекти на екрана @@ -1770,7 +1782,8 @@ Оригиналът на инсталираната версия е запазен: той е пътят назад. Не е запазен Изтрит е оригиналът %1$s на %2$s. - Изтеглянията идват само от версиите Nightlies + Изтеглянията идват само от версиите на Nightlies и DroidDeck + Изтеглянето не бе успешно: тази нощна версия може да е заменена с по-нова. Обновете списъка и опитайте отново. Този списък с пакети е отпреди въвеждането на контролни суми - обнови го и опитай отново Несъответствие в контролната сума @@ -2026,6 +2039,9 @@ Последна синхронизация %1$s Още не е синхронизирано %1$d файла + Вече е актуално + Влезте в магазина, за да синхронизирате записите + Записите не бяха синхронизирани инсталирана в библиотеката ти магазин @@ -2329,7 +2345,7 @@ Готово Сензорното разположение не можа да се запази Сензорното разположение е запазено в Steam - Приложение %1$d + Приложение %1$s Етикет (незадължително) Иконите на Steam не бяха намерени @@ -2420,6 +2436,15 @@ Зрително поле на SteamVR По-ниско приближава SteamVR и запълва очилата; по-високо показва повече около вас. Играете на %1$s + Центриране отново + Меню на SteamVR + Стикове: ръце ⇄ игра + Контролери: %1$s + Клавиатура + Меню на сесията + Спиране на SteamVR + Яркост %1$d / %2$d + Батерия %1$d%% · %2$d °C Калибриране на проследяването Намалява дрейфа и подравнява хоризонта. За тези очила се прилага запазено калибриране. diff --git a/app/src/main/res/values-cs/gestures.xml b/app/src/main/res/values-cs/gestures.xml index 81de9094de..4de0b61198 100644 --- a/app/src/main/res/values-cs/gestures.xml +++ b/app/src/main/res/values-cs/gestures.xml @@ -18,8 +18,6 @@ Jednou kliknout Prodleva podržení Interval dvojitého klepnutí - Platí pro aktuální hru - Výchozí nastavení pro všechny hry Obnovit původní nastavení gest Zrušit Vybrat akci @@ -37,23 +35,16 @@ Kolečko myši Práh gest: %1$d px Zobrazovat rozpoznané gesto - Ovládání myši a klávesnice uspořádané podle gest Jeden prst Dva prsty Tři prsty Možnosti - Vyberte akci pro klepnutí, tažení nebo podržení. - Nastavte posouvání kamery, přiblížení a vedlejší kliknutí. - Mějte další zkratky na dosah. - Upravte pohyb, rozpoznávání a vizuální odezvu. Výchozí Tato hra Použít výchozí - Používá se výchozí nastavení. Úpravou vznikne nastavení pro tuto hru. Uložit změny Zavřít AKCE - Pro %1$s Hledat akce myši nebo klávesy Vymazat hledání Vše @@ -68,12 +59,9 @@ Numerická klávesnice Symboly Pohyb myši - Přímé tažení sleduje polohu dotyku. Relativní tažení sleduje pohyb prstu a hodí se, když hra vrací myš do středu. - Posouvání prostředním tlačítkem vždy sleduje pohyb prstu, aby kurzor nepřeskakoval. Přímé Relativní Rozpoznávání gest - Po překonání této vzdálenosti se gesto dvěma či třemi prsty změní na posouvání nebo přiblížení. Vizuální odezva Chování tlačítka myši %1$d ms diff --git a/app/src/main/res/values-cs/strings.xml b/app/src/main/res/values-cs/strings.xml index 2bef97b92d..9df47991c7 100644 --- a/app/src/main/res/values-cs/strings.xml +++ b/app/src/main/res/values-cs/strings.xml @@ -508,7 +508,9 @@ Smazat tento originál? Tento originál %1$s je z dřívějšího sestavení %2$s. Originál aktuálního sestavení je vždy zachován. Na Nightlies · %1$d - Obnovte pro zobrazení balíčků na Nightlies. + Stabilní + Noční + Obnovte pro zobrazení balíčků na Nightlies a DroidDeck. Od poslední kontroly nic nového. Importovat .wcp Obnovit originál tohoto Protonu @@ -586,6 +588,16 @@ Předchozí stránka Další stránka HUD výkonu + Snímková frekvence + Teplota baterie + Graf výkonu + Barva + Máta + Bílá + Nebeská + Ambrová + Fialová + Průhlednost Režim škálování Ostrost škálování Efekty obrazovky @@ -1812,7 +1824,8 @@ Původní verze nainstalovaného sestavení je zachována: je to cesta zpět. Není uloženo Odstraněna původní verze %2$s z %1$s. - Stahování pochází jen z vydání Nightlies + Stahování pochází jen z vydání Nightlies a DroidDeck + Stažení selhalo: tento noční build mohl být nahrazen novějším. Obnovte seznam a zkuste to znovu. Tento seznam balíčků předchází kontrolním součtům - obnovte ho a zkuste to znovu Neshoda kontrolního součtu @@ -2068,6 +2081,9 @@ Poslední synchronizace %1$s Ještě nesynchronizováno %1$d souborů + Už je aktuální + Pro synchronizaci uložených pozic se přihlaste do obchodu + Uložené pozice nebyly synchronizovány nainstalováno ve vaší knihovně obchod @@ -2375,7 +2391,7 @@ Hotovo Dotykové rozložení se nepodařilo uložit Dotykové rozložení uloženo ve Steamu - Aplikace %1$d + Aplikace %1$s Popisek (nepovinné) Ikony Steamu nebyly nalezeny @@ -2470,6 +2486,15 @@ Zorné pole SteamVR Nižší hodnota přiblíží SteamVR a vyplní brýle; vyšší ukáže víc z okolí. Hraje se na %1$s + Znovu vycentrovat + Nabídka SteamVR + Páčky: ruce ⇄ hra + Ovladače: %1$s + Klávesnice + Nabídka relace + Zastavit SteamVR + Jas %1$d / %2$d + Baterie %1$d%% · %2$d °C Kalibrace sledování Sníží drift a vyrovná vodorovnou referenci. Pro tyto brýle se používá uložená kalibrace. diff --git a/app/src/main/res/values-da/gestures.xml b/app/src/main/res/values-da/gestures.xml index e7b0cc1dc4..fdac523a68 100644 --- a/app/src/main/res/values-da/gestures.xml +++ b/app/src/main/res/values-da/gestures.xml @@ -18,8 +18,6 @@ Klik én gang Forsinkelse før hold Interval for dobbelttryk - Gælder det aktuelle spil - Standardindstillinger for alle spil Gendan de oprindelige bevægelsesindstillinger Annuller Vælg handling @@ -37,23 +35,16 @@ Musehjul Bevægelsestærskel: %1$d px Vis genkendt bevægelse - Muse- og tastaturstyring organiseret efter bevægelse Én finger To fingre Tre fingre Indstillinger - Vælg, hvad et tryk, træk eller hold skal gøre. - Indstil kamerapanorering, zoom og sekundære klik. - Hav flere genveje inden for rækkevidde. - Juster bevægelse, genkendelse og visuel feedback. Standarder Dette spil Brug standardindstillinger - Bruger standardindstillingerne. Redigering opretter særlige indstillinger for spillet. Gem ændringer Luk HANDLING - For %1$s Søg efter musehandlinger eller tastaturtaster Ryd søgning Alle @@ -68,12 +59,9 @@ Numerisk tastatur Symboler Musebevægelse - Direkte træk følger berøringspositionen. Relative træk følger fingerbevægelsen og er nyttige, når et spil centrerer musen. - Panorering med midterste museknap følger altid fingerbevægelsen for at undgå markørspring. Direkte Relativ Genkendelse af bevægelser - Bevæg fingrene så langt, før en bevægelse med to eller tre fingre bliver til panorering eller zoom. Visuel feedback Museknappens funktion %1$d ms diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 3fe4695cba..6b200711de 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -504,7 +504,9 @@ Slet denne original? Denne original af %1$s er fra en tidligere build af %2$s. Den aktuelle builds original bevares altid. På Nightlies · %1$d - Opdater for at se pakker på Nightlies. + Stabil + Nightly + Opdater for at se pakker på Nightlies og DroidDeck. Intet nyt siden sidste kontrol. Importer .wcp Gendan denne Protons original @@ -582,6 +584,16 @@ Forrige side Næste side Ydelses-HUD + Billedhastighed + Batteritemperatur + Ydelsesgraf + Farve + Mint + Hvid + Himmelblå + Ravgul + Violet + Gennemsigtighed Skaleringstilstand Skaleringsskarphed Skærmeffekter @@ -1770,7 +1782,8 @@ Originalen af den installerede version beholdes: den er vejen tilbage. Ikke gemt Slettede %1$s-originalen af %2$s. - Downloads kommer kun fra Nightlies-udgivelserne + Downloads kommer kun fra Nightlies- og DroidDeck-udgivelserne + Download mislykkedes: denne nightly kan være erstattet af en nyere build. Opdater listen, og prøv igen. Denne pakkeliste er ældre end tjeksummer - opdater den, og forsøg igen Tjeksum stemmer ikke @@ -2026,6 +2039,9 @@ Senest synkroniseret %1$s Ikke synkroniseret endnu %1$d filer + Allerede opdateret + Log ind i butikken for at synkronisere gemte spil + Gemte spil blev ikke synkroniseret installeret i dit bibliotek butik @@ -2329,7 +2345,7 @@ Udført Berøringslayoutet kunne ikke gemmes Berøringslayout gemt i Steam - App %1$d + App %1$s Etiket (valgfrit) Steams ikoner blev ikke fundet @@ -2420,6 +2436,15 @@ SteamVR-synsfelt Lavere bringer SteamVR tættere på og fylder brillen; højere viser mere omkring dig. Spiller på %1$s + Centrér igen + SteamVR-menu + Pinde: hænder ⇄ spil + Controllere: %1$s + Tastatur + Sessionsmenu + Stop SteamVR + Lysstyrke %1$d / %2$d + Batteri %1$d%% · %2$d °C Sporingskalibrering Mindsker drift og justerer den vandrette reference. Gemt kalibrering anvendes på denne brille. diff --git a/app/src/main/res/values-de/gestures.xml b/app/src/main/res/values-de/gestures.xml index 22b750ece8..47532cd741 100644 --- a/app/src/main/res/values-de/gestures.xml +++ b/app/src/main/res/values-de/gestures.xml @@ -18,8 +18,6 @@ Einmal klicken Halteverzögerung Doppeltipp-Intervall - Gilt für das aktuelle Spiel - Standardeinstellungen für alle Spiele Ursprüngliche Gesteneinstellungen wiederherstellen Abbrechen Aktion auswählen @@ -37,23 +35,16 @@ Mausrad Gestenschwelle: %1$d px Erkannte Geste anzeigen - Maus- und Tastatursteuerung nach Gesten geordnet Ein Finger Zwei Finger Drei Finger Optionen - Wähle die Aktion für Tippen, Ziehen oder Halten. - Kameraschwenks, Zoom und sekundäre Klicks anpassen. - Zusätzliche Kurzbefehle griffbereit halten. - Bewegung, Erkennung und visuelle Rückmeldung anpassen. Standardwerte Dieses Spiel Standardeinstellungen verwenden - Standardeinstellungen werden verwendet. Änderungen erstellen eine Spielanpassung. Änderungen speichern Schließen AKTION - Für %1$s Mausaktionen oder Tastaturtasten suchen Suche leeren Alle @@ -68,12 +59,9 @@ Ziffernblock Symbole Mausbewegung - Direktes Ziehen folgt der Berührungsposition. Relatives Ziehen folgt der Fingerbewegung und eignet sich für Spiele, die die Maus zentrieren. - Schwenks mit mittlerer Maustaste folgen immer der Fingerbewegung, um Zeigersprünge zu vermeiden. Direkt Relativ Gestenerkennung - Bewege die Finger um diese Strecke, bevor eine Zwei- oder Dreifingergeste als Schwenken oder Zoomen gilt. Visuelle Rückmeldung Verhalten der Maustaste %1$d ms diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 9fe1c0e794..d284aa1275 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -501,7 +501,9 @@ Dieses Original löschen? Dieses %1$s-Original stammt aus einem früheren Build von %2$s. Das Original des aktuellen Builds wird immer behalten. In den Nightlies · %1$d - Aktualisiere, um die Pakete in den Nightlies aufzulisten. + Stabil + Nightly + Aktualisiere, um die Pakete in den Nightlies und bei DroidDeck aufzulisten. Nichts Neues seit der letzten Prüfung. .wcp importieren Original dieses Protons wiederherstellen @@ -579,6 +581,16 @@ Vorherige Seite Nächste Seite Leistungs-HUD + Bildrate + Akkutemperatur + Leistungsdiagramm + Farbe + Minze + Weiß + Himmelblau + Bernstein + Violett + Deckkraft Skalierungsmodus Skalierungsschärfe Bildschirmeffekte @@ -1759,7 +1771,8 @@ Das Original des installierten Builds bleibt erhalten: Es ist der Weg zurück. Nicht gespeichert Das %1$s-Original von %2$s wurde gelöscht. - Downloads kommen nur aus den Nightlies-Releases + Downloads kommen nur aus den Nightlies- und DroidDeck-Releases + Download fehlgeschlagen: Dieser Nightly-Build wurde vielleicht durch einen neueren ersetzt. Aktualisiere die Liste und versuche es erneut. Diese Paketliste stammt aus der Zeit vor Prüfsummen - aktualisiere sie und versuche es erneut Prüfsumme stimmt nicht überein @@ -2015,6 +2028,9 @@ Zuletzt synchronisiert %1$s Noch nicht synchronisiert %1$d Dateien + Bereits aktuell + Im Store anmelden, um Spielstände zu synchronisieren + Spielstände wurden nicht synchronisiert installiert in deiner Bibliothek Store @@ -2315,7 +2331,7 @@ Fertig Das Touch-Layout konnte nicht gespeichert werden Touch-Layout in Steam gespeichert - App %1$d + App %1$s Bezeichnung (optional) Steams Symbole wurden nicht gefunden @@ -2406,6 +2422,15 @@ SteamVR-Sichtfeld Niedriger holt SteamVR näher heran und füllt die Brille; höher zeigt mehr von deiner Umgebung. Spiel läuft auf %1$s + Neu zentrieren + SteamVR-Menü + Sticks: Hände ⇄ Spiel + Controller: %1$s + Tastatur + Sitzungsmenü + SteamVR beenden + Helligkeit %1$d / %2$d + Akku %1$d%% · %2$d °C Tracking-Kalibrierung Verringert Drift und richtet die waagerechte Referenz aus. Für diese Brille wird eine gespeicherte Kalibrierung verwendet. diff --git a/app/src/main/res/values-el/gestures.xml b/app/src/main/res/values-el/gestures.xml index 65b86e4a7a..22d20ba936 100644 --- a/app/src/main/res/values-el/gestures.xml +++ b/app/src/main/res/values-el/gestures.xml @@ -18,8 +18,6 @@ Ένα κλικ Καθυστέρηση κρατήματος Διάστημα διπλού πατήματος - Ισχύει για το τρέχον παιχνίδι - Προεπιλεγμένες ρυθμίσεις για όλα τα παιχνίδια Επαναφορά αρχικών ρυθμίσεων χειρονομιών Ακύρωση Επιλογή ενέργειας @@ -37,23 +35,16 @@ Ροδέλα ποντικιού Όριο χειρονομιών: %1$d px Εμφάνιση αναγνωρισμένης χειρονομίας - Χειρισμοί ποντικιού και πληκτρολογίου ανά χειρονομία Ένα δάχτυλο Δύο δάχτυλα Τρία δάχτυλα Επιλογές - Επιλέξτε την ενέργεια για πάτημα, σύρσιμο ή κράτημα. - Ρυθμίστε τη μετατόπιση της κάμερας, τη μεγέθυνση και τα δευτερεύοντα κλικ. - Κρατήστε επιπλέον συντομεύσεις κοντά σας. - Ρυθμίστε την κίνηση, την αναγνώριση και την οπτική ανάδραση. Προεπιλογές Αυτό το παιχνίδι Χρήση προεπιλογών - Χρησιμοποιούνται οι προεπιλογές. Η επεξεργασία δημιουργεί ρυθμίσεις για αυτό το παιχνίδι. Αποθήκευση αλλαγών Κλείσιμο ΕΝΕΡΓΕΙΑ - Για %1$s Αναζήτηση ενεργειών ποντικιού ή πλήκτρων Εκκαθάριση αναζήτησης Όλα @@ -68,12 +59,9 @@ Αριθμητικό πληκτρολόγιο Σύμβολα Κίνηση ποντικιού - Το άμεσο σύρσιμο ακολουθεί τη θέση αφής. Το σχετικό σύρσιμο ακολουθεί την κίνηση του δαχτύλου, χρήσιμο όταν το παιχνίδι επαναφέρει το ποντίκι στο κέντρο. - Η μετατόπιση με το μεσαίο κουμπί ακολουθεί πάντα την κίνηση του δαχτύλου για να αποφεύγονται άλματα του δείκτη. Απευθείας Σχετική Αναγνώριση χειρονομιών - Κινηθείτε κατά αυτή την απόσταση προτού μια χειρονομία με δύο ή τρία δάχτυλα γίνει μετατόπιση ή μεγέθυνση. Οπτική ανάδραση Συμπεριφορά κουμπιού ποντικιού %1$d ms diff --git a/app/src/main/res/values-el/strings.xml b/app/src/main/res/values-el/strings.xml index 14f83431cf..409cda9ecf 100644 --- a/app/src/main/res/values-el/strings.xml +++ b/app/src/main/res/values-el/strings.xml @@ -504,7 +504,9 @@ Διαγραφή αυτού του πρωτοτύπου; Αυτό το πρωτότυπο %1$s είναι από προηγούμενο build του %2$s. Το πρωτότυπο του τρέχοντος build διατηρείται πάντα. Στα Nightlies · %1$d - Ανανεώστε για να εμφανιστούν τα πακέτα στα Nightlies. + Σταθερή + Νυχτερινή + Ανανεώστε για να εμφανιστούν τα πακέτα στα Nightlies και στο DroidDeck. Τίποτα νέο από τον τελευταίο έλεγχο. Εισαγωγή .wcp Επαναφορά του πρωτοτύπου αυτού του Proton @@ -582,6 +584,16 @@ Προηγούμενη σελίδα Επόμενη σελίδα HUD απόδοσης + Ρυθμός καρέ + Θερμοκρασία μπαταρίας + Γράφημα απόδοσης + Χρώμα + Μέντα + Λευκό + Γαλάζιο + Κεχριμπαρί + Βιολετί + Διαφάνεια Λειτουργία κλιμάκωσης Οξύτητα κλιμάκωσης Εφέ οθόνης @@ -1770,7 +1782,8 @@ Το αρχικό της εγκατεστημένης έκδοσης διατηρείται: είναι ο δρόμος της επιστροφής. Δεν είναι αποθηκευμένο Διαγράφηκε το αρχικό %1$s του %2$s. - Οι λήψεις προέρχονται μόνο από τις κυκλοφορίες Nightlies + Οι λήψεις προέρχονται μόνο από τις κυκλοφορίες Nightlies και DroidDeck + Η λήψη απέτυχε: αυτή η νυχτερινή έκδοση ίσως αντικαταστάθηκε από νεότερη. Ανανεώστε τη λίστα και δοκιμάστε ξανά. Αυτή η λίστα πακέτων προηγείται των αθροισμάτων ελέγχου - ανανεώστε την και δοκιμάστε ξανά Αναντιστοιχία αθροίσματος ελέγχου @@ -2026,6 +2039,9 @@ Τελευταίος συγχρονισμός %1$s Δεν έχει συγχρονιστεί ακόμα %1$d αρχεία + Ήδη ενημερωμένο + Συνδεθείτε στο κατάστημα για συγχρονισμό αποθηκεύσεων + Οι αποθηκεύσεις δεν συγχρονίστηκαν εγκατεστημένο στη βιβλιοθήκη σας κατάστημα @@ -2329,7 +2345,7 @@ Τέλος Δεν ήταν δυνατή η αποθήκευση της διάταξης αφής Η διάταξη αφής αποθηκεύτηκε στο Steam - Εφαρμογή %1$d + Εφαρμογή %1$s Ετικέτα (προαιρετικό) Τα εικονίδια του Steam δεν βρέθηκαν @@ -2420,6 +2436,15 @@ Οπτικό πεδίο SteamVR Χαμηλότερο: το SteamVR έρχεται πιο κοντά και γεμίζει τα γυαλιά· υψηλότερο: βλέπετε περισσότερα γύρω σας. Παίζετε στα %1$s + Επανακεντράρισμα + Μενού SteamVR + Μοχλοί: χέρια ⇄ παιχνίδι + Χειριστήρια: %1$s + Πληκτρολόγιο + Μενού συνεδρίας + Διακοπή SteamVR + Φωτεινότητα %1$d / %2$d + Μπαταρία %1$d%% · %2$d °C Βαθμονόμηση παρακολούθησης Μειώνει την ολίσθηση και ευθυγραμμίζει την οριζόντια αναφορά. Σε αυτά τα γυαλιά εφαρμόζεται αποθηκευμένη βαθμονόμηση. diff --git a/app/src/main/res/values-es/gestures.xml b/app/src/main/res/values-es/gestures.xml index 13a89a1b84..4f5f49779b 100644 --- a/app/src/main/res/values-es/gestures.xml +++ b/app/src/main/res/values-es/gestures.xml @@ -18,8 +18,6 @@ Hacer clic una vez Tiempo de pulsación sostenida Intervalo de doble toque - Se aplica al juego actual - Ajustes predeterminados para todos los juegos Restablecer los ajustes originales de gestos Cancelar Elegir acción @@ -37,23 +35,16 @@ Rueda del ratón Umbral de gestos: %1$d px Mostrar gesto reconocido - Controles de ratón y teclado organizados por gesto Un dedo Dos dedos Tres dedos Opciones - Elige qué debe hacer un toque, arrastre o pulsación sostenida. - Configura el movimiento de cámara, el zoom y los clics secundarios. - Ten más accesos directos al alcance de la mano. - Ajusta el movimiento, el reconocimiento y la respuesta visual. Predeterminados Este juego Usar valores predeterminados - Se usan los ajustes predeterminados. Al editarlos, se crean ajustes específicos del juego. Guardar cambios Cerrar ACCIÓN - Para %1$s Buscar acciones de ratón o teclas del teclado Borrar búsqueda Todas @@ -68,12 +59,9 @@ Teclado numérico Símbolos Movimiento del ratón - El arrastre directo sigue la posición del toque. El relativo sigue el movimiento del dedo y resulta útil cuando un juego centra el ratón. - El desplazamiento con el botón central siempre sigue el movimiento del dedo para evitar saltos del cursor. Directo Relativo Reconocimiento de gestos - Recorre esta distancia antes de que un gesto con dos o tres dedos se convierta en desplazamiento o zoom. Respuesta visual Comportamiento del botón del ratón %1$d ms diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index ea6e05fb38..85e1bf0a4b 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -307,6 +307,8 @@ Cliente Superposición de rendimiento Desactívalo si los juegos fallan o se quedan en negro en modo Deck. Se aplica en la próxima sesión. + Volver a DroidDeck al cerrar un juego + Cuando se cierra un juego que iniciaste desde DroidDeck u otro lanzador, Steam se cierra correctamente (primero termina de sincronizar las partidas en la nube) y vuelves allí. Desactivado: te quedas en Steam. Reparar el cliente de Steam Vuelve a descargar el cliente de Steam la próxima vez que se inicie Steam. Úsalo si Steam se queda en la pantalla de carga. Se conservan los juegos, la sesión iniciada y los ajustes. El cliente de Steam se volverá a descargar la próxima vez que se inicie Steam. @@ -503,7 +505,9 @@ ¿Eliminar este original? Este original de %1$s es de una versión anterior de %2$s. El original de la versión actual siempre se conserva. En las Nightlies · %1$d - Actualiza para listar los paquetes de las Nightlies. + Estable + Nocturna + Actualiza para listar los paquetes de Nightlies y DroidDeck. Nada nuevo desde la última comprobación. Importar .wcp Restaurar el original de este Proton @@ -581,6 +585,16 @@ Página anterior Página siguiente HUD de rendimiento + Tasa de fotogramas + Temperatura de la batería + Gráfico de rendimiento + Color + Menta + Blanco + Celeste + Ámbar + Violeta + Opacidad Modo de escalado Nitidez del escalado Efectos de pantalla @@ -1788,7 +1802,8 @@ El original de la versión instalada se conserva: es el camino de vuelta. No guardado Se eliminó el original de %1$s de %2$s. - Las descargas solo proceden de las versiones Nightlies + Las descargas solo proceden de las versiones de Nightlies y DroidDeck + Error en la descarga: puede que esta compilación nocturna se haya sustituido por una más reciente. Actualiza la lista y vuelve a intentarlo. Esta lista de paquetes es anterior a las sumas de verificación - actualízala e inténtalo de nuevo La suma de verificación no coincide @@ -2044,6 +2059,9 @@ Última sincronización %1$s Aún sin sincronizar %1$d archivos + Ya está al día + Inicia sesión en la tienda para sincronizar las partidas + No se sincronizaron las partidas instalado en tu biblioteca tienda @@ -2346,7 +2364,7 @@ Hecho No se pudo guardar la disposición táctil Disposición táctil guardada en Steam - App %1$d + App %1$s Etiqueta (opcional) No se encontraron los iconos de Steam @@ -2428,6 +2446,15 @@ Campo de visión de SteamVR Más bajo acerca SteamVR y llena las gafas; más alto muestra más a tu alrededor. Jugando en %1$s + Recentrar + Menú de SteamVR + Sticks: manos ⇄ juego + Mandos: %1$s + Teclado + Menú de sesión + Detener SteamVR + Brillo %1$d / %2$d + Batería %1$d%% · %2$d °C Calibración del seguimiento Reduce la deriva y alinea la referencia horizontal. Estas gafas usan la calibración guardada. diff --git a/app/src/main/res/values-fi/gestures.xml b/app/src/main/res/values-fi/gestures.xml index 1cca2cb40e..c92357b99a 100644 --- a/app/src/main/res/values-fi/gestures.xml +++ b/app/src/main/res/values-fi/gestures.xml @@ -18,8 +18,6 @@ Napsauta kerran Pidon viive Kaksoisnapautuksen aikaväli - Koskee nykyistä peliä - Kaikkien pelien oletusasetukset Palauta alkuperäiset eleasetukset Peruuta Valitse toiminto @@ -37,23 +35,16 @@ Hiiren rulla Elekynnys: %1$d px Näytä tunnistettu ele - Hiiri- ja näppäimistöohjaus eleittäin Yksi sormi Kaksi sormea Kolme sormea Asetukset - Valitse napautuksen, vedon tai pidon toiminto. - Määritä kameran panorointi, zoomaus ja toissijaiset napsautukset. - Pidä lisäpikakomennot ulottuvillasi. - Säädä liikettä, tunnistusta ja visuaalista palautetta. Oletukset Tämä peli Käytä oletuksia - Oletusasetukset ovat käytössä. Muokkaaminen luo pelikohtaiset asetukset. Tallenna muutokset Sulje TOIMINTO - Kohteelle %1$s Etsi hiiritoimintoja tai näppäimiä Tyhjennä haku Kaikki @@ -68,12 +59,9 @@ Numeronäppäimistö Symbolit Hiiren liike - Suora veto seuraa kosketuskohtaa. Suhteellinen veto seuraa sormen liikettä ja sopii peleihin, jotka keskittävät hiiren. - Panorointi keskipainikkeella seuraa aina sormen liikettä, jotta osoitin ei hypi. Suora Suhteellinen Eleiden tunnistus - Liikuta sormia tämän matkan verran, ennen kuin kahden tai kolmen sormen ele muuttuu panoroinniksi tai zoomaukseksi. Visuaalinen palaute Hiiripainikkeen toiminta %1$d ms diff --git a/app/src/main/res/values-fi/strings.xml b/app/src/main/res/values-fi/strings.xml index 680b9c455c..b6757f5e74 100644 --- a/app/src/main/res/values-fi/strings.xml +++ b/app/src/main/res/values-fi/strings.xml @@ -504,7 +504,9 @@ Poistetaanko tämä alkuperäinen? Tämä %1$s:n alkuperäinen on aiemmasta %2$s-versiosta. Nykyisen version alkuperäinen säilytetään aina. Nightliesissä · %1$d - Päivitä nähdäksesi Nightliesin paketit. + Vakaa + Yöversio + Päivitä nähdäksesi Nightliesin ja DroidDeckin paketit. Ei mitään uutta viimeisimmän tarkistuksen jälkeen. Tuo .wcp Palauta tämän Protonin alkuperäinen @@ -582,6 +584,16 @@ Edellinen sivu Seuraava sivu Suorituskyky-HUD + Kuvataajuus + Akun lämpötila + Suorituskykykäyrä + Väri + Minttu + Valkoinen + Taivaansininen + Meripihka + Violetti + Peittävyys Skaalaustila Skaalauksen terävyys Näyttötehosteet @@ -1770,7 +1782,8 @@ Asennetun version alkuperäinen säilytetään: se on tie takaisin. Ei tallennettu Poistettu %2$s:n %1$s-alkuperäinen. - Lataukset tulevat vain Nightlies-julkaisuista + Lataukset tulevat vain Nightlies- ja DroidDeck-julkaisuista + Lataus epäonnistui: tämä yöversio on ehkä korvattu uudemmalla. Päivitä luettelo ja yritä uudelleen. Tämä pakettiluettelo on tarkistussummia vanhempi - päivitä se ja yritä uudelleen Tarkistussumma ei täsmää @@ -2026,6 +2039,9 @@ Viimeisin synkronointi %1$s Ei synkronoitu vielä %1$d tiedostoa + Jo ajan tasalla + Kirjaudu kauppaan synkronoidaksesi tallennukset + Tallennuksia ei synkronoitu asennettu kirjastossasi kauppa @@ -2329,7 +2345,7 @@ Valmis Kosketusasettelua ei voitu tallentaa Kosketusasettelu tallennettu Steamiin - Sovellus %1$d + Sovellus %1$s Nimike (valinnainen) Steamin kuvakkeita ei löytynyt @@ -2420,6 +2436,15 @@ SteamVR:n näkökenttä Pienempi tuo SteamVR:n lähemmäs ja täyttää lasit; suurempi näyttää enemmän ympäriltäsi. Pelataan laitteella %1$s + Keskitä uudelleen + SteamVR-valikko + Sauvat: kädet ⇄ peli + Ohjaimet: %1$s + Näppäimistö + Istuntovalikko + Pysäytä SteamVR + Kirkkaus %1$d / %2$d + Akku %1$d%% · %2$d °C Seurannan kalibrointi Vähentää ryömintää ja kohdistaa vaakatason. Tallennettu kalibrointi on käytössä näissä laseissa. diff --git a/app/src/main/res/values-fr/gestures.xml b/app/src/main/res/values-fr/gestures.xml index 72c9b6a0b1..031725fa1a 100644 --- a/app/src/main/res/values-fr/gestures.xml +++ b/app/src/main/res/values-fr/gestures.xml @@ -18,8 +18,6 @@ Cliquer une fois Délai de maintien Intervalle du double appui - S\'applique au jeu actuel - Paramètres par défaut pour tous les jeux Rétablir les paramètres des gestes d\'origine Annuler Choisir une action @@ -37,23 +35,16 @@ Molette de la souris Seuil des gestes : %1$d px Afficher le geste reconnu - Commandes de souris et de clavier organisées par geste Un doigt Deux doigts Trois doigts Options - Choisissez l\'action d\'un appui, d\'un glissement ou d\'un maintien. - Configurez les déplacements de caméra, le zoom et les clics secondaires. - Gardez des raccourcis supplémentaires à portée de main. - Ajustez les mouvements, la reconnaissance et le retour visuel. Valeurs par défaut Ce jeu Utiliser les valeurs par défaut - Paramètres par défaut utilisés. Une modification crée des paramètres propres au jeu. Enregistrer les modifications Fermer ACTION - Pour %1$s Rechercher des actions de souris ou des touches du clavier Effacer la recherche Tout @@ -68,12 +59,9 @@ Pavé numérique Symboles Mouvement de la souris - Le glissement direct suit la position du toucher. Le glissement relatif suit le mouvement du doigt, utile lorsqu\'un jeu recentre la souris. - Le déplacement avec le bouton du milieu suit toujours le mouvement du doigt pour éviter les sauts du curseur. Direct Relatif Reconnaissance des gestes - Parcourez cette distance avant qu\'un geste à deux ou trois doigts soit reconnu comme un déplacement ou un zoom. Retour visuel Comportement du bouton de souris %1$d ms diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 1072156283..af743337c4 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -307,6 +307,8 @@ Client Superposition de performance Désactivez cette option si les jeux plantent ou affichent un écran noir en mode Deck. Prendra effet à la prochaine session. + Revenir à DroidDeck après un jeu + Quand un jeu lancé depuis DroidDeck ou un autre lanceur se ferme, Steam se ferme proprement (après la synchronisation des sauvegardes cloud) et vous y revenez. Désactivé : vous restez dans Steam. Réparer le client Steam Retélécharge le client Steam au prochain démarrage de Steam. Utile si Steam reste bloqué sur son écran de chargement. Les jeux, la connexion et les paramètres sont conservés. Le client Steam sera retéléchargé au prochain démarrage de Steam. @@ -503,7 +505,9 @@ Supprimer cette version originale ? Cette version originale de %1$s provient d\'une version antérieure de %2$s. La version originale de la version actuelle sera toujours conservée. Dans Nightlies · %1$d - Actualiser pour lister les paquets dans Nightlies. + Stable + Nightly + Actualiser pour lister les paquets dans Nightlies et DroidDeck. Aucun nouvel élément depuis la dernière vérification. Importer .wcp Restaurer les fichiers originaux de ce Proton @@ -581,6 +585,16 @@ Page précédente Page suivante HUD de performance + Fréquence d\'images + Température de la batterie + Graphique de performance + Couleur + Menthe + Blanc + Ciel + Ambre + Violet + Opacité Mode de mise à l\'échelle Netteté de la mise à l\'échelle Effets d\'écran @@ -1788,7 +1802,8 @@ L\'original de la version installée est conservé : c\'est le moyen d\'y revenir. Non enregistré Original %1$s de %2$s supprimé. - Les téléchargements proviennent uniquement des versions Nightlies + Les téléchargements proviennent uniquement des versions Nightlies et DroidDeck + Échec du téléchargement : cette version nightly a peut-être été remplacée par une plus récente. Actualisez la liste et réessayez. Cette liste de paquets est antérieure aux sommes de contrôle - actualisez-la et réessayez Somme de contrôle incorrecte @@ -2044,6 +2059,9 @@ Dernière synchro : %1$s Pas encore synchronisé %1$d fichiers + Déjà à jour + Connectez-vous à la boutique pour synchroniser les sauvegardes + Les sauvegardes n’ont pas été synchronisées installé dans votre bibliothèque boutique @@ -2346,7 +2364,7 @@ Terminé Impossible d\'enregistrer la disposition tactile Disposition tactile enregistrée sur Steam - Appli %1$d + Appli %1$s Libellé (facultatif) Les icônes de Steam n\'ont pas été trouvées @@ -2439,6 +2457,15 @@ Champ de vision SteamVR Plus bas rapproche SteamVR et remplit les lunettes ; plus haut montre davantage autour de vous. En jeu sur %1$s + Recentrer + Menu SteamVR + Sticks : mains ⇄ jeu + Manettes : %1$s + Clavier + Menu de session + Arrêter SteamVR + Luminosité %1$d / %2$d + Batterie %1$d%% · %2$d °C Calibrage du suivi Réduit la dérive et aligne la référence horizontale. Le calibrage enregistré est appliqué à ces lunettes. diff --git a/app/src/main/res/values-hi/gestures.xml b/app/src/main/res/values-hi/gestures.xml index 7d4a2365e9..12bdd6381d 100644 --- a/app/src/main/res/values-hi/gestures.xml +++ b/app/src/main/res/values-hi/gestures.xml @@ -18,8 +18,6 @@ एक बार क्लिक करें दबाए रखने का विलंब दो टैप के बीच का अंतराल - मौजूदा गेम पर लागू होता है - सभी गेम की डिफ़ॉल्ट सेटिंग जेस्चर की मूल सेटिंग वापस लाएँ रद्द करें कार्रवाई चुनें @@ -37,23 +35,16 @@ माउस व्हील जेस्चर की सीमा: %1$d पिक्सेल पहचाना गया जेस्चर दिखाएँ - जेस्चर के अनुसार माउस और कीबोर्ड कंट्रोल एक उँगली दो उँगलियाँ तीन उँगलियाँ विकल्प - चुनें कि टैप करने, खींचने या दबाए रखने पर क्या हो। - कैमरा खिसकाना, ज़ूम और दूसरे क्लिक सेट करें। - अतिरिक्त शॉर्टकट आसानी से इस्तेमाल करें। - गति, पहचान और दृश्य प्रतिक्रिया में बदलाव करें। डिफ़ॉल्ट यह गेम डिफ़ॉल्ट इस्तेमाल करें - डिफ़ॉल्ट सेटिंग इस्तेमाल हो रही हैं। बदलाव करने पर इस गेम की अलग सेटिंग बनेंगी। बदलाव सेव करें बंद करें कार्रवाई - %1$s के लिए माउस की कार्रवाइयाँ या कीबोर्ड की कुंजियाँ खोजें खोज मिटाएँ सभी @@ -68,12 +59,9 @@ नंबर पैड चिह्न माउस की गति - सीधे खींचना छुई गई जगह के अनुसार चलता है। सापेक्ष खींचना उँगली की गति के अनुसार चलता है और गेम के माउस को बीच में लाने पर उपयोगी है। - माउस के बीच वाले बटन से दृश्य खिसकाना हमेशा उँगली की गति के अनुसार चलता है, ताकि कर्सर न उछले। डायरेक्ट सापेक्ष जेस्चर की पहचान - दो या तीन उँगलियों का जेस्चर दृश्य खिसकाने या ज़ूम में बदलने से पहले इतनी दूरी तय करें। दृश्य प्रतिक्रिया माउस बटन का व्यवहार %1$d मिलीसेकंड diff --git a/app/src/main/res/values-hi/strings.xml b/app/src/main/res/values-hi/strings.xml index 2a246077fb..38eac11933 100644 --- a/app/src/main/res/values-hi/strings.xml +++ b/app/src/main/res/values-hi/strings.xml @@ -504,7 +504,9 @@ यह ओरिजिनल हटाएं? यह %1$s ओरिजिनल %2$s के पहले वाले बिल्ड से है। मौजूदा बिल्ड का ओरिजिनल हमेशा रखा जाता है। Nightlies पर · %1$d - Nightlies के पैकेज सूचीबद्ध करने के लिए रीफ़्रेश करें। + स्थिर + नाइटली + Nightlies और DroidDeck के पैकेज सूचीबद्ध करने के लिए रीफ़्रेश करें। पिछली जांच के बाद कुछ नया नहीं है। .wcp इंपोर्ट करें इस Proton का ओरिजिनल वापस लाएं @@ -582,6 +584,16 @@ पिछला पेज अगला पेज परफ़ॉर्मेंस HUD + फ़्रेम दर + बैटरी तापमान + परफ़ॉर्मेंस ग्राफ़ + रंग + मिंट + सफ़ेद + स्काई + एम्बर + वायलेट + ओपैसिटी स्केलिंग मोड स्केलिंग शार्पनेस स्क्रीन इफ़ेक्ट @@ -1770,7 +1782,8 @@ इंस्टॉल किए बिल्ड का ओरिजिनल रखा गया है: यह वापस जाने का रास्ता है। सेव नहीं है %2$s का %1$s ओरिजिनल हटाया गया। - डाउनलोड सिर्फ़ Nightlies रिलीज़ से आते हैं + डाउनलोड सिर्फ़ Nightlies और DroidDeck रिलीज़ से आते हैं + डाउनलोड विफल: हो सकता है यह नाइटली बिल्ड किसी नए बिल्ड से बदल दिया गया हो। सूची रीफ़्रेश करें और फिर से कोशिश करें। यह पैकेज लिस्ट चेकसम से पुरानी है - इसे रीफ़्रेश करें और फिर कोशिश करें चेकसम मेल नहीं खाया @@ -2026,6 +2039,9 @@ आख़िरी सिंक %1$s अभी सिंक नहीं हुआ %1$d फ़ाइलें + पहले से अप टू डेट + सेव सिंक करने के लिए स्टोर में साइन इन करें + सेव सिंक नहीं हुए इंस्टॉल है आपकी लाइब्रेरी में स्टोर @@ -2329,7 +2345,7 @@ हो गया टच लेआउट सेव नहीं हो सका टच लेआउट Steam में सेव हो गया - ऐप %1$d + ऐप %1$s लेबल (वैकल्पिक) Steam के आइकॉन नहीं मिले @@ -2420,6 +2436,15 @@ SteamVR फ़ील्ड ऑफ़ व्यू कम करने पर SteamVR पास आता है और चश्मा भर देता है; ज़्यादा करने पर आपके आस-पास ज़्यादा दिखता है। %1$s पर खेल रहे हैं + फिर से केंद्रित करें + SteamVR मेनू + स्टिक: हाथ ⇄ गेम + कंट्रोलर: %1$s + कीबोर्ड + सत्र मेनू + SteamVR रोकें + चमक %1$d / %2$d + बैटरी %1$d%% · %2$d °C ट्रैकिंग कैलिब्रेशन ड्रिफ़्ट कम करता है और क्षैतिज संदर्भ को सीध में लाता है। इस चश्मे पर सेव किया गया कैलिब्रेशन लागू है। diff --git a/app/src/main/res/values-hu/gestures.xml b/app/src/main/res/values-hu/gestures.xml index 359224c549..e5279c2e23 100644 --- a/app/src/main/res/values-hu/gestures.xml +++ b/app/src/main/res/values-hu/gestures.xml @@ -18,8 +18,6 @@ Egyszeri kattintás Nyomva tartás késleltetése Dupla koppintás időköze - Az aktuális játékra érvényes - Alapbeállítások minden játékhoz Eredeti gesztusbeállítások visszaállítása Mégse Művelet kiválasztása @@ -37,23 +35,16 @@ Egérgörgő Gesztusküszöb: %1$d px Felismert gesztus megjelenítése - Egér- és billentyűzetvezérlés gesztusok szerint Egy ujj Két ujj Három ujj Beállítások - Válaszd ki a koppintás, húzás vagy nyomva tartás műveletét. - Állítsd be a kamera pásztázását, a nagyítást és a másodlagos kattintásokat. - Tarts további gyorsparancsokat kéznél. - Finomhangold a mozgást, a felismerést és a vizuális visszajelzést. Alapértelmezések Ez a játék Alapbeállítások használata - Az alapbeállítások érvényesek. A szerkesztés játékhoz tartozó beállításokat hoz létre. Módosítások mentése Bezárás MŰVELET - Ehhez: %1$s Egérműveletek vagy billentyűk keresése Keresés törlése Összes @@ -68,12 +59,9 @@ Numerikus billentyűzet Szimbólumok Egérmozgás - A közvetlen húzás az érintési helyet követi. A relatív húzás az ujj mozgását követi, ami hasznos, ha a játék középre állítja az egeret. - A középső egérgombos pásztázás mindig az ujj mozgását követi, hogy a kurzor ne ugorjon el. Közvetlen Relatív Gesztusfelismerés - Ennyit kell elmozdítani az ujjakat, mielőtt a két- vagy háromujjas gesztus pásztázássá vagy nagyítássá válik. Vizuális visszajelzés Egérgomb működése %1$d ms diff --git a/app/src/main/res/values-hu/strings.xml b/app/src/main/res/values-hu/strings.xml index ab5bbef494..a307b5aedd 100644 --- a/app/src/main/res/values-hu/strings.xml +++ b/app/src/main/res/values-hu/strings.xml @@ -504,7 +504,9 @@ Törli ezt az eredetit? Ez a %1$s eredeti a %2$s egy korábbi buildjéből származik. Az aktuális build eredetije mindig megmarad. A Nightliesen · %1$d - Frissítsen a Nightliesen lévő csomagok listázásához. + Stabil + Nightly + Frissítsen a Nightlies és a DroidDeck csomagjainak listázásához. Nincs semmi új az utolsó ellenőrzés óta. .wcp importálása Ennek a Protonnak az eredetijének visszaállítása @@ -582,6 +584,16 @@ Előző oldal Következő oldal Teljesítmény HUD + Képkockasebesség + Akkuhőmérséklet + Teljesítménygrafikon + Szín + Menta + Fehér + Égszínkék + Borostyán + Lila + Átlátszatlanság Méretezési mód Méretezési élesség Képernyőeffektek @@ -1770,7 +1782,8 @@ A telepített build eredetije megmarad: ez a visszaút. Nincs tárolva A %2$s %1$s eredetije törölve. - A letöltések csak a Nightlies kiadásokból érkeznek + A letöltések csak a Nightlies és a DroidDeck kiadásokból érkeznek + A letöltés sikertelen: lehet, hogy ezt a nightly buildet egy újabb váltotta. Frissítse a listát, és próbálja újra. Ez a csomaglista régebbi, mint az ellenőrzőösszegek – frissítse, és próbálja újra Az ellenőrzőösszeg nem egyezik @@ -2026,6 +2039,9 @@ Utolsó szinkronizálás: %1$s Még nincs szinkronizálva %1$d fájl + Már naprakész + Jelentkezz be az áruházba a mentések szinkronizálásához + A mentések nem lettek szinkronizálva telepítve a könyvtárában áruház @@ -2329,7 +2345,7 @@ Kész Az érintőelrendezést nem sikerült elmenteni Az érintőelrendezés elmentve a Steambe - %1$d. alkalmazás + %1$s. alkalmazás Felirat (nem kötelező) A Steam ikonjai nem találhatók @@ -2420,6 +2436,15 @@ SteamVR látómező Kisebb érték közelebb hozza a SteamVR-t és kitölti a szemüveget; nagyobb többet mutat a környezetéből. Játék ezen: %1$s + Középre igazítás + SteamVR menü + Karok: kezek ⇄ játék + Kontrollerek: %1$s + Billentyűzet + Munkamenet menü + SteamVR leállítása + Fényerő %1$d / %2$d + Akkumulátor %1$d%% · %2$d °C Követés kalibrálása Csökkenti a sodródást, és beállítja a vízszintes referenciát. A szemüveg a mentett kalibrációt használja. diff --git a/app/src/main/res/values-in/gestures.xml b/app/src/main/res/values-in/gestures.xml index 67a82a4e21..3bf4b33e56 100644 --- a/app/src/main/res/values-in/gestures.xml +++ b/app/src/main/res/values-in/gestures.xml @@ -18,8 +18,6 @@ Klik sekali Jeda sebelum menahan Interval ketuk dua kali - Berlaku untuk game saat ini - Setelan default untuk semua game Pulihkan setelan gestur awal Batal Pilih tindakan @@ -37,23 +35,16 @@ Roda mouse Ambang gestur: %1$d px Tampilkan gestur yang dikenali - Kontrol mouse dan keyboard menurut gestur Satu jari Dua jari Tiga jari Opsi - Pilih tindakan saat mengetuk, menyeret, atau menahan. - Atur pergeseran kamera, zoom, dan klik sekunder. - Jangkau lebih banyak pintasan dengan mudah. - Sesuaikan gerakan, pengenalan, dan umpan balik visual. Default Game ini Gunakan default - Menggunakan setelan default. Mengedit akan membuat setelan khusus game. Simpan perubahan Tutup TINDAKAN - Untuk %1$s Cari tindakan mouse atau tombol keyboard Hapus pencarian Semua @@ -68,12 +59,9 @@ Keypad numerik Simbol Gerakan mouse - Seret langsung mengikuti posisi sentuhan. Seret relatif mengikuti gerakan jari, berguna saat game memusatkan mouse. - Pergeseran dengan tombol tengah mouse selalu mengikuti gerakan jari agar kursor tidak melompat. Langsung Relatif Pengenalan gestur - Gerakkan sejauh ini sebelum gestur dua atau tiga jari menjadi pergeseran atau zoom. Umpan balik visual Perilaku tombol mouse %1$d md diff --git a/app/src/main/res/values-in/strings.xml b/app/src/main/res/values-in/strings.xml index 0bd3c783ff..f1cbe95432 100644 --- a/app/src/main/res/values-in/strings.xml +++ b/app/src/main/res/values-in/strings.xml @@ -502,7 +502,9 @@ Hapus yang asli ini? %1$s asli ini berasal dari build %2$s yang lebih lama. Asli build saat ini selalu dipertahankan. Di Nightlies · %1$d - Segarkan untuk melihat daftar paket di Nightlies. + Stabil + Nightly + Segarkan untuk melihat daftar paket di Nightlies dan DroidDeck. Tidak ada yang baru sejak pemeriksaan terakhir. Impor .wcp Pulihkan yang asli dari Proton ini @@ -580,6 +582,16 @@ Halaman sebelumnya Halaman berikutnya HUD performa + Laju bingkai + Suhu baterai + Grafik performa + Warna + Mint + Putih + Langit + Ambar + Ungu + Opasitas Mode penskalaan Ketajaman penskalaan Efek layar @@ -1749,7 +1761,8 @@ Yang asli dari build terinstal disimpan: itulah cara untuk kembali. Tidak tersimpan Menghapus yang asli %1$s dari %2$s. - Unduhan hanya berasal dari rilis Nightlies + Unduhan hanya berasal dari rilis Nightlies dan DroidDeck + Unduhan gagal: build nightly ini mungkin sudah diganti dengan yang lebih baru. Segarkan daftar lalu coba lagi. Daftar paket ini dibuat sebelum adanya checksum - segarkan dan coba lagi Checksum tidak cocok @@ -2005,6 +2018,9 @@ Sinkronisasi terakhir %1$s Belum disinkronkan %1$d file + Sudah terbaru + Masuk ke toko untuk menyinkronkan simpanan + Simpanan tidak disinkronkan terinstal dalam pustaka Anda toko @@ -2306,7 +2322,7 @@ Selesai Tata letak sentuh tidak dapat disimpan Tata letak sentuh disimpan ke Steam - App %1$d + App %1$s Label (opsional) Ikon Steam tidak ditemukan @@ -2395,6 +2411,15 @@ Bidang pandang SteamVR Lebih rendah membawa SteamVR lebih dekat dan memenuhi kacamata; lebih tinggi menampilkan lebih banyak di sekitar Anda. Bermain di %1$s + Pusatkan ulang + Menu SteamVR + Stik: tangan ⇄ game + Kontroler: %1$s + Keyboard + Menu sesi + Hentikan SteamVR + Kecerahan %1$d / %2$d + Baterai %1$d%% · %2$d °C Kalibrasi pelacakan Mengurangi drift dan menyelaraskan acuan horizontal. Kalibrasi tersimpan diterapkan ke kacamata ini. diff --git a/app/src/main/res/values-it/gestures.xml b/app/src/main/res/values-it/gestures.xml index 07475d5d7f..b9a3147f48 100644 --- a/app/src/main/res/values-it/gestures.xml +++ b/app/src/main/res/values-it/gestures.xml @@ -18,8 +18,6 @@ Clic singolo Ritardo della pressione Intervallo del doppio tocco - Si applica al gioco attuale - Impostazioni predefinite per tutti i giochi Ripristina le impostazioni originali dei gesti Annulla Scegli azione @@ -37,23 +35,16 @@ Rotellina del mouse Soglia dei gesti: %1$d px Mostra il gesto riconosciuto - Comandi di mouse e tastiera organizzati per gesto Un dito Due dita Tre dita Opzioni - Scegli l\'azione di un tocco, trascinamento o pressione. - Configura lo spostamento della visuale, lo zoom e i clic secondari. - Tieni altre scorciatoie a portata di mano. - Regola movimento, riconoscimento e riscontro visivo. Predefiniti Questo gioco Usa impostazioni predefinite - Sono in uso le impostazioni predefinite. Una modifica crea impostazioni specifiche del gioco. Salva modifiche Chiudi AZIONE - Per %1$s Cerca azioni del mouse o tasti della tastiera Cancella ricerca Tutte @@ -68,12 +59,9 @@ Tastierino numerico Simboli Movimento del mouse - Il trascinamento diretto segue la posizione del tocco. Quello relativo segue il movimento del dito ed è utile quando un gioco ricentra il mouse. - Lo spostamento con il pulsante centrale segue sempre il movimento del dito per evitare salti del cursore. Diretto Relativo Riconoscimento dei gesti - Percorri questa distanza prima che un gesto con due o tre dita diventi uno spostamento o uno zoom. Riscontro visivo Comportamento del pulsante del mouse %1$d ms diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index a2c2c3c4c5..9493ae1b15 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -503,7 +503,9 @@ Eliminare questo originale? Questo originale di %1$s proviene da una build precedente di %2$s. L\'originale della build attuale viene sempre conservato. Nelle Nightlies · %1$d - Aggiorna per elencare i pacchetti nelle Nightlies. + Stabile + Nightly + Aggiorna per elencare i pacchetti nelle Nightlies e in DroidDeck. Niente di nuovo dall\'ultimo controllo. Importa .wcp Ripristina l\'originale di questo Proton @@ -581,6 +583,16 @@ Pagina precedente Pagina successiva HUD prestazioni + Frequenza fotogrammi + Temperatura batteria + Grafico prestazioni + Colore + Menta + Bianco + Cielo + Ambra + Viola + Opacità Modalità di ridimensionamento Nitidezza del ridimensionamento Effetti schermo @@ -1780,7 +1792,8 @@ L\'originale della build installata viene conservato: serve per tornare indietro. Non salvato Originale %1$s di %2$s eliminato. - I download provengono solo dalle release Nightly + I download provengono solo dalle release Nightly e DroidDeck + Download non riuscito: questa build nightly potrebbe essere stata sostituita da una più recente. Aggiorna l’elenco e riprova. Questo elenco di pacchetti è anteriore ai checksum - aggiornalo e riprova Checksum non corrispondente @@ -2036,6 +2049,9 @@ Ultima sincronizzazione %1$s Non ancora sincronizzato %1$d file + Già aggiornato + Accedi allo store per sincronizzare i salvataggi + I salvataggi non sono stati sincronizzati installato nella tua libreria negozio @@ -2338,7 +2354,7 @@ Fine Impossibile salvare il layout touch Layout touch salvato su Steam - App %1$d + App %1$s Etichetta (opzionale) Le icone di Steam non sono state trovate @@ -2431,6 +2447,15 @@ Campo visivo di SteamVR Più basso avvicina SteamVR e riempie gli occhiali; più alto mostra di più intorno a te. Gioco in corso su %1$s + Ricentra + Menu di SteamVR + Levette: mani ⇄ gioco + Controller: %1$s + Tastiera + Menu della sessione + Arresta SteamVR + Luminosità %1$d / %2$d + Batteria %1$d%% · %2$d °C Calibrazione del tracciamento Riduce la deriva e allinea il riferimento orizzontale. La calibrazione salvata è applicata a questi occhiali. diff --git a/app/src/main/res/values-ja/gestures.xml b/app/src/main/res/values-ja/gestures.xml index 7568885f2c..961a4ec218 100644 --- a/app/src/main/res/values-ja/gestures.xml +++ b/app/src/main/res/values-ja/gestures.xml @@ -18,8 +18,6 @@ 1回クリック 長押しの待ち時間 ダブルタップの間隔 - 現在のゲームに適用 - すべてのゲームの既定設定 ジェスチャーの設定を初期状態に戻す キャンセル 操作を選択 @@ -37,23 +35,16 @@ マウスホイール ジェスチャーのしきい値:%1$d px 認識したジェスチャーを表示 - ジェスチャー別のマウスとキーボード操作 1本指 2本指 3本指 オプション - タップ、ドラッグ、長押しの動作を選択します。 - カメラ移動、ズーム、補助クリックを設定します。 - 追加のショートカットを手元に配置します。 - 移動、認識、視覚的フィードバックを調整します。 デフォルト このゲーム 既定値を使用 - 既定設定を使用しています。編集するとゲーム固有の設定が作成されます。 変更を保存 閉じる 操作 - %1$sの操作 マウス操作やキーボードのキーを検索 検索をクリア すべて @@ -68,12 +59,9 @@ テンキー 記号 マウスの移動 - 直接ドラッグはタッチ位置に従います。相対ドラッグは指の動きに従い、ゲームがマウスを中央に戻す場合に適しています。 - カーソルの飛びを防ぐため、中ボタンによる視点移動は常に指の動きに従います。 ダイレクト 相対 ジェスチャー認識 - 2本指または3本指のジェスチャーが視点移動やズームになるまでに必要な移動距離です。 視覚的フィードバック マウスボタンの動作 %1$dミリ秒 diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 213144bea4..143351f826 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -310,6 +310,8 @@ クライアント パフォーマンスオーバーレイ Deckモードでゲームがクラッシュしたり画面が真っ暗になる場合は、これをオフにしてください。次回のセッションで有効になります。 + ゲーム終了後にDroidDeckへ戻る + DroidDeckや他のランチャーから起動したゲームを閉じると、Steamが正しく終了し(クラウドセーブの同期を先に完了)、起動元に戻ります。オフ:Steamに留まります。 Steamクライアントを修復 次回Steamの起動時にSteamクライアントを再ダウンロードします。Steamが読み込み画面のまま進まない場合に使用してください。ゲーム、ログイン情報、設定は保持されます。 次回Steamの起動時にSteamクライアントを再ダウンロードします。 @@ -502,7 +504,9 @@ この元のバージョンを削除しますか? この%1$sの元のバージョンは、%2$sの以前のビルドのものです。現在のビルドの元のバージョンは常に保持されます。 Nightlies内 · %1$d - 更新してNightliesのパッケージを一覧表示します。 + 安定版 + ナイトリー + 更新してNightliesとDroidDeckのパッケージを一覧表示します。 前回の確認以降、新しいものはありません。 .wcpをインポート このProtonの元のファイルを復元 @@ -580,6 +584,16 @@ 前のページ 次のページ パフォーマンスHUD + フレームレート + バッテリー温度 + パフォーマンスグラフ + 色 + ミント + ホワイト + スカイ + アンバー + バイオレット + 不透明度 スケーリングモード スケーリングのシャープネス 画面エフェクト @@ -1749,7 +1763,8 @@ インストール済みビルドの元のファイルは、元に戻すために保持されます。 保存されていません %2$sの%1$s版の元のファイルを削除しました。 - ダウンロードはNightliesのリリースからのみ行われます + ダウンロードはNightliesとDroidDeckのリリースからのみ行われます + ダウンロードに失敗しました:このナイトリービルドは新しいビルドに置き換えられた可能性があります。一覧を更新してもう一度お試しください。 このパッケージ一覧はチェックサム導入前のものです。更新してからもう一度お試しください チェックサムが一致しません @@ -2005,6 +2020,9 @@ 最終同期 %1$s 未同期 %1$d個のファイル + すでに最新です + セーブを同期するにはストアにサインインしてください + セーブは同期されませんでした インストール済み ライブラリ内 ストア @@ -2306,7 +2324,7 @@ 完了 タッチレイアウトを保存できませんでした タッチレイアウトをSteamに保存しました - アプリ%1$d + アプリ%1$s ラベル(任意) Steamのアイコンが見つかりませんでした @@ -2395,6 +2413,15 @@ SteamVR の視野角 小さくすると SteamVR が近くなりグラスいっぱいに広がり、大きくすると周囲が広く見えます。 %1$s でプレイ中 + 中心をリセット + SteamVR メニュー + スティック: 手 ⇄ ゲーム + コントローラー: %1$s + キーボード + セッションメニュー + SteamVR を停止 + 明るさ %1$d / %2$d + バッテリー %1$d%% · %2$d °C トラッキングのキャリブレーション ドリフトを減らし、水平の基準を合わせます。 保存したキャリブレーションをこのグラスに適用しています。 diff --git a/app/src/main/res/values-ko/gestures.xml b/app/src/main/res/values-ko/gestures.xml index 5ca6d89f5b..9f32380c4d 100644 --- a/app/src/main/res/values-ko/gestures.xml +++ b/app/src/main/res/values-ko/gestures.xml @@ -18,8 +18,6 @@ 한 번 클릭 길게 누르기 대기 시간 두 번 탭 간격 - 현재 게임에 적용 - 모든 게임의 기본 설정 제스처 설정을 초기 상태로 재설정 취소 동작 선택 @@ -37,23 +35,16 @@ 마우스 휠 제스처 임계값: %1$d px 인식된 제스처 표시 - 제스처별 마우스 및 키보드 조작 한 손가락 두 손가락 세 손가락 옵션 - 탭, 드래그, 길게 누르기의 동작을 선택하세요. - 카메라 이동, 확대/축소, 보조 클릭을 설정하세요. - 추가 단축 동작을 손쉽게 사용하세요. - 이동, 인식, 시각적 피드백을 조정하세요. 기본값 이 게임 기본값 사용 - 기본 설정을 사용 중입니다. 수정하면 게임별 설정이 생성됩니다. 변경 사항 저장 닫기 동작 - %1$s 동작 마우스 동작 또는 키보드 키 검색 검색 지우기 전체 @@ -68,12 +59,9 @@ 숫자 키패드 기호 마우스 이동 - 직접 드래그는 터치 위치를 따릅니다. 상대 드래그는 손가락 움직임을 따르며, 게임에서 마우스를 중앙으로 돌려놓을 때 유용합니다. - 커서가 튀지 않도록 가운데 버튼 이동은 항상 손가락 움직임을 따릅니다. 직접 터치 상대 제스처 인식 - 두 손가락 또는 세 손가락 제스처가 카메라 이동이나 확대/축소로 인식되기 위한 이동 거리입니다. 시각적 피드백 마우스 버튼 동작 %1$d ms diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 4fc869f78f..901a84e7da 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -310,6 +310,8 @@ 클라이언트 성능 오버레이 Deck 모드에서 게임이 충돌하거나 화면이 검게 변하면 이 옵션을 끄세요. 다음 세션에 적용됩니다. + 게임 종료 후 DroidDeck으로 돌아가기 + DroidDeck 또는 다른 런처에서 실행한 게임을 닫으면 Steam이 정상적으로 종료되고(클라우드 저장 동기화를 먼저 완료) 실행한 곳으로 돌아갑니다. 끄면 Steam에 머무릅니다. Steam 클라이언트 복구 다음에 Steam을 시작할 때 Steam 클라이언트를 다시 다운로드합니다. Steam이 로딩 화면에서 넘어가지 않을 때 사용하세요. 게임, 로그인 정보 및 설정은 유지됩니다. 다음에 Steam을 시작할 때 Steam 클라이언트를 다시 다운로드합니다. @@ -502,7 +504,9 @@ 이 원본 버전을 삭제하시겠습니까? 이 %1$s 원본 버전은 %2$s의 이전 빌드에서 가져온 것입니다. 현재 빌드의 원본 버전은 항상 유지됩니다. Nightlies 내 · %1$d - 새로 고쳐 Nightlies의 패키지를 나열합니다. + 안정판 + 나이틀리 + 새로 고쳐 Nightlies 및 DroidDeck의 패키지를 나열합니다. 마지막 확인 이후 새로운 내용이 없습니다. .wcp 가져오기 이 Proton의 원본 파일 복원 @@ -580,6 +584,16 @@ 이전 페이지 다음 페이지 성능 HUD + 프레임 속도 + 배터리 온도 + 성능 그래프 + 색상 + 민트 + 흰색 + 하늘색 + 호박색 + 보라색 + 불투명도 스케일링 모드 스케일링 선명도 화면 효과 @@ -1749,7 +1763,8 @@ 설치된 빌드의 원본은 되돌리기 위해 유지됩니다. 저장되지 않음 %2$s의 %1$s 원본을 삭제했습니다. - Nightlies 릴리스에서만 다운로드할 수 있습니다 + Nightlies 및 DroidDeck 릴리스에서만 다운로드할 수 있습니다 + 다운로드 실패: 이 나이틀리 빌드가 더 새로운 빌드로 교체되었을 수 있습니다. 목록을 새로 고친 후 다시 시도하세요. 이 패키지 목록은 체크섬 도입 이전의 것입니다. 새로 고친 후 다시 시도하세요 체크섬 불일치 @@ -2005,6 +2020,9 @@ 마지막 동기화 %1$s 아직 동기화 안 됨 파일 %1$d개 + 이미 최신 상태입니다 + 저장 파일을 동기화하려면 스토어에 로그인하세요 + 저장 파일이 동기화되지 않았습니다 설치됨 내 라이브러리 스토어 @@ -2306,7 +2324,7 @@ 완료 터치 레이아웃을 저장할 수 없습니다 터치 레이아웃이 Steam에 저장되었습니다 - 앱 %1$d + 앱 %1$s 라벨(선택 사항) Steam 아이콘을 찾을 수 없습니다 @@ -2395,6 +2413,15 @@ SteamVR 시야각 낮추면 SteamVR이 가까워져 안경을 가득 채우고, 높이면 주변이 더 넓게 보입니다. %1$s에서 플레이 중 + 중앙 재설정 + SteamVR 메뉴 + 스틱: 손 ⇄ 게임 + 컨트롤러: %1$s + 키보드 + 세션 메뉴 + SteamVR 중지 + 밝기 %1$d / %2$d + 배터리 %1$d%% · %2$d °C 트래킹 보정 드리프트를 줄이고 수평 기준을 맞춥니다. 저장된 보정이 이 안경에 적용되어 있습니다. diff --git a/app/src/main/res/values-ms/gestures.xml b/app/src/main/res/values-ms/gestures.xml index f4762ac34a..67f5d20911 100644 --- a/app/src/main/res/values-ms/gestures.xml +++ b/app/src/main/res/values-ms/gestures.xml @@ -18,8 +18,6 @@ Klik sekali Lengah sebelum menahan Sela ketikan dua kali - Digunakan untuk permainan semasa - Tetapan lalai untuk semua permainan Pulihkan tetapan gerak isyarat asal Batal Pilih tindakan @@ -37,23 +35,16 @@ Roda tetikus Ambang gerak isyarat: %1$d px Tunjukkan gerak isyarat yang dikenal pasti - Kawalan tetikus dan papan kekunci mengikut gerak isyarat Satu jari Dua jari Tiga jari Pilihan - Pilih tindakan apabila mengetik, menyeret atau menahan. - Tetapkan sorotan kamera, zum dan klik sekunder. - Pastikan pintasan tambahan mudah dicapai. - Laraskan pergerakan, pengecaman dan maklum balas visual. Lalai Permainan ini Gunakan lalai - Menggunakan tetapan lalai. Penyuntingan mencipta tetapan khusus permainan. Simpan perubahan Tutup TINDAKAN - Untuk %1$s Cari tindakan tetikus atau kekunci papan kekunci Kosongkan carian Semua @@ -68,12 +59,9 @@ Pad nombor Simbol Pergerakan tetikus - Seretan langsung mengikut kedudukan sentuhan. Seretan relatif mengikut pergerakan jari dan berguna apabila permainan memusatkan tetikus. - Sorotan dengan butang tengah tetikus sentiasa mengikut pergerakan jari untuk mengelakkan lompatan kursor. Terus Relatif Pengecaman gerak isyarat - Gerakkan sejauh ini sebelum gerak isyarat dua atau tiga jari menjadi sorotan atau zum. Maklum balas visual Kelakuan butang tetikus %1$d ms diff --git a/app/src/main/res/values-ms/strings.xml b/app/src/main/res/values-ms/strings.xml index 599ff582f9..6c5acab203 100644 --- a/app/src/main/res/values-ms/strings.xml +++ b/app/src/main/res/values-ms/strings.xml @@ -502,7 +502,9 @@ Padam yang asal ini? %1$s asal ini daripada binaan terdahulu %2$s. Yang asal bagi binaan semasa sentiasa dikekalkan. Pada Nightlies · %1$d - Segarkan semula untuk menyenaraikan pakej pada Nightlies. + Stabil + Nightly + Segarkan semula untuk menyenaraikan pakej pada Nightlies dan DroidDeck. Tiada apa-apa yang baharu sejak semakan terakhir. Import .wcp Pulihkan yang asal bagi Proton ini @@ -580,6 +582,16 @@ Halaman sebelumnya Halaman seterusnya HUD prestasi + Kadar bingkai + Suhu bateri + Graf prestasi + Warna + Pudina + Putih + Langit + Ambar + Ungu + Kelegapan Mod penskalaan Ketajaman penskalaan Kesan skrin @@ -1749,7 +1761,8 @@ Asal binaan yang dipasang dikekalkan: itulah jalan kembali. Tidak disimpan Asal %1$s bagi %2$s telah dipadam. - Muat turun hanya datang daripada keluaran Nightlies + Muat turun hanya datang daripada keluaran Nightlies dan DroidDeck + Muat turun gagal: binaan nightly ini mungkin telah diganti dengan yang lebih baharu. Segarkan semula senarai dan cuba lagi. Senarai pakej ini mendahului checksum - segarkan dan cuba lagi Checksum tidak sepadan @@ -2005,6 +2018,9 @@ Segerak terakhir %1$s Belum disegerakkan %1$d fail + Sudah terkini + Log masuk ke kedai untuk menyegerakkan simpanan + Simpanan tidak disegerakkan dipasang dalam pustaka anda kedai @@ -2306,7 +2322,7 @@ Selesai Susun atur sentuh tidak dapat disimpan Susun atur sentuh disimpan ke Steam - Apl %1$d + Apl %1$s Label (pilihan) Ikon Steam tidak dijumpai @@ -2395,6 +2411,15 @@ Medan pandangan SteamVR Lebih rendah mendekatkan SteamVR dan memenuhi cermin mata; lebih tinggi menunjukkan lebih banyak di sekeliling anda. Bermain pada %1$s + Pusatkan semula + Menu SteamVR + Kayu bedik: tangan ⇄ permainan + Pengawal: %1$s + Papan kekunci + Menu sesi + Hentikan SteamVR + Kecerahan %1$d / %2$d + Bateri %1$d%% · %2$d °C Penentukuran penjejakan Mengurangkan hanyutan dan menjajarkan rujukan mendatar. Penentukuran yang disimpan digunakan pada cermin mata ini. diff --git a/app/src/main/res/values-nb/gestures.xml b/app/src/main/res/values-nb/gestures.xml index 77330e3c39..4f41438505 100644 --- a/app/src/main/res/values-nb/gestures.xml +++ b/app/src/main/res/values-nb/gestures.xml @@ -18,8 +18,6 @@ Klikk én gang Forsinkelse før hold Intervall for dobbelttrykk - Gjelder det gjeldende spillet - Standardinnstillinger for alle spill Gjenopprett de opprinnelige bevegelsesinnstillingene Avbryt Velg handling @@ -37,23 +35,16 @@ Musehjul Bevegelsesterskel: %1$d px Vis gjenkjent bevegelse - Muse- og tastaturstyring organisert etter bevegelse Én finger To fingre Tre fingre Alternativer - Velg hva et trykk, drag eller hold skal gjøre. - Still inn kamerapanorering, zoom og sekundære klikk. - Ha flere snarveier innen rekkevidde. - Juster bevegelse, gjenkjenning og visuell tilbakemelding. Standardverdier Dette spillet Bruk standardinnstillinger - Standardinnstillinger brukes. Redigering oppretter egne innstillinger for spillet. Lagre endringer Lukk HANDLING - For %1$s Søk etter musehandlinger eller tastaturtaster Tøm søket Alle @@ -68,12 +59,9 @@ Numerisk tastatur Symboler Musebevegelse - Direkte draing følger berøringsposisjonen. Relativ draing følger fingerbevegelsen og er nyttig når et spill sentrerer musen. - Panorering med midtre museknapp følger alltid fingerbevegelsen for å unngå markørhopp. Direkte Relativ Gjenkjenning av bevegelser - Beveg fingrene så langt før en bevegelse med to eller tre fingre blir til panorering eller zoom. Visuell tilbakemelding Museknappens funksjon %1$d ms diff --git a/app/src/main/res/values-nb/strings.xml b/app/src/main/res/values-nb/strings.xml index 68dcfc185a..6bbab58190 100644 --- a/app/src/main/res/values-nb/strings.xml +++ b/app/src/main/res/values-nb/strings.xml @@ -504,7 +504,9 @@ Slette denne originalen? Denne %1$s-originalen er fra en tidligere build av %2$s. Den gjeldende buildens original beholdes alltid. På Nightlies · %1$d - Oppdater for å liste pakker på Nightlies. + Stabil + Nightly + Oppdater for å liste pakker på Nightlies og DroidDeck. Ingenting nytt siden siste sjekk. Importer .wcp Gjenopprett denne Protonens original @@ -582,6 +584,16 @@ Forrige side Neste side Ytelses-HUD + Bildefrekvens + Batteritemperatur + Ytelsesgraf + Farge + Mint + Hvit + Himmel + Amber + Fiolett + Opasitet Skaleringsmodus Skaleringsskarphet Skjermeffekter @@ -1770,7 +1782,8 @@ Originalen til den installerte builden beholdes: det er veien tilbake. Ikke lagret Slettet %1$s-originalen av %2$s. - Nedlastinger kommer bare fra Nightlies-utgivelsene + Nedlastinger kommer bare fra Nightlies- og DroidDeck-utgivelsene + Nedlastingen mislyktes: denne nightly-versjonen kan være erstattet av en nyere. Oppdater listen og prøv igjen. Denne pakkelisten er eldre enn sjekksummene – oppdater den og prøv igjen Sjekksummen stemmer ikke @@ -2026,6 +2039,9 @@ Siste synkronisering %1$s Ikke synkronisert ennå %1$d filer + Allerede oppdatert + Logg inn i butikken for å synkronisere lagrede spill + Lagrede spill ble ikke synkronisert installert i biblioteket ditt butikk @@ -2329,7 +2345,7 @@ Fullført Kunne ikke lagre berøringsoppsettet Berøringsoppsett lagret til Steam - App %1$d + App %1$s Etikett (valgfritt) Steams ikoner ble ikke funnet @@ -2420,6 +2436,15 @@ SteamVR-synsfelt Lavere bringer SteamVR nærmere og fyller brillene; høyere viser mer rundt deg. Spiller på %1$s + Sentrer på nytt + SteamVR-meny + Spaker: hender ⇄ spill + Kontrollere: %1$s + Tastatur + Øktmeny + Stopp SteamVR + Lysstyrke %1$d / %2$d + Batteri %1$d%% · %2$d °C Sporingskalibrering Reduserer avdrift og retter inn horisontreferansen. Lagret kalibrering brukes for disse brillene. diff --git a/app/src/main/res/values-nl/gestures.xml b/app/src/main/res/values-nl/gestures.xml index 1b225d5ad4..a970becd5c 100644 --- a/app/src/main/res/values-nl/gestures.xml +++ b/app/src/main/res/values-nl/gestures.xml @@ -18,8 +18,6 @@ Eenmaal klikken Wachttijd voor vasthouden Interval voor dubbeltikken - Geldt voor het huidige spel - Standaardinstellingen voor alle spellen Oorspronkelijke gebareninstellingen herstellen Annuleren Actie kiezen @@ -37,23 +35,16 @@ Muiswiel Gebaardrempel: %1$d px Herkend gebaar tonen - Muis- en toetsenbordbediening per gebaar Eén vinger Twee vingers Drie vingers Opties - Kies wat tikken, slepen of vasthouden doet. - Stel camerabewegingen, zoomen en secundaire klikken in. - Houd extra sneltoetsen binnen handbereik. - Pas beweging, herkenning en visuele feedback aan. Standaardinstellingen Dit spel Standaardinstellingen gebruiken - Standaardinstellingen zijn actief. Bewerken maakt instellingen voor dit spel. Wijzigingen opslaan Sluiten ACTIE - Voor %1$s Zoek muisacties of toetsen Zoekopdracht wissen Alle @@ -68,12 +59,9 @@ Numeriek toetsenblok Symbolen Muisbeweging - Direct slepen volgt de aanraakpositie. Relatief slepen volgt de vingerbeweging en is handig als een spel de muis opnieuw centreert. - Pannen met de middelste muisknop volgt altijd de vingerbeweging om cursorsprongen te voorkomen. Direct Relatief Gebarenherkenning - Beweeg deze afstand voordat een gebaar met twee of drie vingers overgaat in pannen of zoomen. Visuele feedback Gedrag van de muisknop %1$d ms diff --git a/app/src/main/res/values-nl/strings.xml b/app/src/main/res/values-nl/strings.xml index 267afcb69c..12400b3e86 100644 --- a/app/src/main/res/values-nl/strings.xml +++ b/app/src/main/res/values-nl/strings.xml @@ -504,7 +504,9 @@ Dit origineel verwijderen? Dit origineel van %1$s komt uit een eerdere build van %2$s. Het origineel van de huidige build wordt altijd bewaard. In de Nightlies · %1$d - Vernieuw om de pakketten in de Nightlies te tonen. + Stabiel + Nightly + Vernieuw om de pakketten in de Nightlies en bij DroidDeck te tonen. Niets nieuws sinds de laatste controle. .wcp importeren Origineel van deze Proton herstellen @@ -582,6 +584,16 @@ Vorige pagina Volgende pagina Prestatie-HUD + Beeldsnelheid + Accutemperatuur + Prestatiegrafiek + Kleur + Mint + Wit + Hemelsblauw + Amber + Violet + Transparantie Schaalmodus Schaalscherpte Schermeffecten @@ -1770,7 +1782,8 @@ Het origineel van de geïnstalleerde build wordt bewaard: dat is de weg terug. Niet opgeslagen Het %1$s-origineel van %2$s is verwijderd. - Downloads komen alleen van de Nightlies-releases + Downloads komen alleen van de Nightlies- en DroidDeck-releases + Download mislukt: deze nightly is mogelijk vervangen door een nieuwere build. Vernieuw de lijst en probeer het opnieuw. Deze pakketlijst is ouder dan de checksums - vernieuw de lijst en probeer het opnieuw Checksum komt niet overeen @@ -2026,6 +2039,9 @@ Laatste synchronisatie %1$s Nog niet gesynchroniseerd %1$d bestanden + Al up-to-date + Log in bij de winkel om opslagbestanden te synchroniseren + Opslagbestanden zijn niet gesynchroniseerd geïnstalleerd in je bibliotheek winkel @@ -2329,7 +2345,7 @@ Klaar De aanraakindeling kon niet worden opgeslagen Aanraakindeling opgeslagen in Steam - App %1$d + App %1$s Label (optioneel) Steams pictogrammen zijn niet gevonden @@ -2420,6 +2436,15 @@ SteamVR-gezichtsveld Lager brengt SteamVR dichterbij en vult de bril; hoger toont meer om je heen. Je speelt op %1$s + Opnieuw centreren + SteamVR-menu + Sticks: handen ⇄ spel + Controllers: %1$s + Toetsenbord + Sessiemenu + SteamVR stoppen + Helderheid %1$d / %2$d + Batterij %1$d%% · %2$d °C Trackingkalibratie Vermindert drift en lijnt de horizontale referentie uit. De opgeslagen kalibratie wordt op deze bril toegepast. diff --git a/app/src/main/res/values-pl/gestures.xml b/app/src/main/res/values-pl/gestures.xml index 9ff5f867bb..8325469e7e 100644 --- a/app/src/main/res/values-pl/gestures.xml +++ b/app/src/main/res/values-pl/gestures.xml @@ -18,8 +18,6 @@ Kliknij raz Czas przytrzymania Odstęp podwójnego stuknięcia - Dotyczy bieżącej gry - Ustawienia domyślne dla wszystkich gier Przywróć pierwotne ustawienia gestów Anuluj Wybierz akcję @@ -37,23 +35,16 @@ Kółko myszy Próg gestów: %1$d px Pokaż rozpoznany gest - Sterowanie myszą i klawiaturą pogrupowane według gestów Jeden palec Dwa palce Trzy palce Opcje - Wybierz działanie stuknięcia, przeciągania lub przytrzymania. - Skonfiguruj przesuwanie kamery, przybliżanie i kliknięcia pomocnicze. - Miej dodatkowe skróty pod ręką. - Dostosuj ruch, rozpoznawanie i wizualne potwierdzenia. Domyślne Ta gra Użyj domyślnych - Używane są ustawienia domyślne. Edycja tworzy ustawienia dla tej gry. Zapisz zmiany Zamknij AKCJA - Dla %1$s Szukaj akcji myszy lub klawiszy klawiatury Wyczyść wyszukiwanie Wszystkie @@ -68,12 +59,9 @@ Klawiatura numeryczna Symbole Ruch myszy - Przeciąganie bezpośrednie podąża za pozycją dotyku. Względne podąża za ruchem palca i przydaje się, gdy gra centruje mysz. - Przesuwanie środkowym przyciskiem myszy zawsze podąża za ruchem palca, aby uniknąć skoków kursora. Bezpośredni Względny Rozpoznawanie gestów - Przesuń palce o tę odległość, zanim gest dwoma lub trzema palcami stanie się przesuwaniem lub przybliżaniem. Wizualne potwierdzenia Działanie przycisku myszy %1$d ms diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index fc7bb39b1a..d80cd8cec9 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -508,7 +508,9 @@ Usunąć ten oryginał? Ten oryginał %1$s pochodzi z wcześniejszej wersji %2$s. Oryginał bieżącej wersji jest zawsze zachowywany. W wersjach nightly · %1$d - Odśwież, aby wyświetlić pakiety w wersjach nightly. + Stabilna + Nightly + Odśwież, aby wyświetlić pakiety w Nightlies i DroidDeck. Nic nowego od ostatniego sprawdzenia. Importuj .wcp Przywróć oryginał tego Proton @@ -586,6 +588,16 @@ Poprzednia strona Następna strona HUD wydajności + Liczba klatek + Temperatura baterii + Wykres wydajności + Kolor + Mięta + Biały + Błękitny + Bursztynowy + Fioletowy + Przezroczystość Tryb skalowania Ostrość skalowania Efekty ekranowe @@ -1812,7 +1824,8 @@ Oryginał zainstalowanej wersji zostaje zachowany: to droga powrotu. Nie przechowywano Usunięto oryginał %2$s z %1$s. - Pobieranie odbywa się tylko z wydań Nightlies + Pobieranie odbywa się tylko z wydań Nightlies i DroidDeck + Pobieranie nie powiodło się: ta wersja nightly mogła zostać zastąpiona nowszą. Odśwież listę i spróbuj ponownie. Ta lista pakietów jest starsza niż sumy kontrolne – odśwież ją i spróbuj ponownie Niezgodna suma kontrolna @@ -2068,6 +2081,9 @@ Ostatnia synchronizacja %1$s Jeszcze nie zsynchronizowano %1$d plików + Już aktualne + Zaloguj się do sklepu, aby synchronizować zapisy + Zapisy nie zostały zsynchronizowane zainstalowana w Twojej bibliotece sklep @@ -2146,6 +2162,9 @@ Menedżer pobierania Pobierania naraz Instaluj w + Język gry + GOG i Epic instalują w tym języku. System to język aplikacji. + Systemowy Zainstaluj %1$s: Wewnętrzna %1$s wolnego miejsca @@ -2375,7 +2394,7 @@ Gotowe Nie udało się zapisać układu dotykowego Układ dotykowy zapisany w Steam - Aplikacja %1$d + Aplikacja %1$s Etykieta (opcjonalnie) Nie znaleziono ikon Steam @@ -2470,6 +2489,15 @@ Pole widzenia SteamVR Mniejsze przybliża SteamVR i wypełnia okulary; większe pokazuje więcej dookoła. Grasz na: %1$s + Wyśrodkuj ponownie + Menu SteamVR + Gałki: dłonie ⇄ gra + Kontrolery: %1$s + Klawiatura + Menu sesji + Zatrzymaj SteamVR + Jasność %1$d / %2$d + Bateria %1$d%% · %2$d °C Kalibracja śledzenia Ogranicza dryf i wyrównuje poziom odniesienia. Dla tych okularów używana jest zapisana kalibracja. diff --git a/app/src/main/res/values-pt-rPT/gestures.xml b/app/src/main/res/values-pt-rPT/gestures.xml index 610ebc4148..2d8f3cf8ea 100644 --- a/app/src/main/res/values-pt-rPT/gestures.xml +++ b/app/src/main/res/values-pt-rPT/gestures.xml @@ -18,8 +18,6 @@ Clicar uma vez Tempo para manter premido Intervalo de toque duplo - Aplica-se ao jogo atual - Configurações padrão para todos os jogos Restaurar as configurações originais de gestos Cancelar Escolher ação @@ -37,23 +35,16 @@ Roda do rato Limiar dos gestos: %1$d px Mostrar gesto reconhecido - Controlos de rato e teclado organizados por gesto Um dedo Dois dedos Três dedos Opções - Escolha o que um toque, arraste ou toque mantido deve fazer. - Configure o movimento da câmera, o zoom e os cliques secundários. - Mantenha mais atalhos ao alcance dos dedos. - Ajuste o movimento, o reconhecimento e a resposta visual. Valores padrão Este jogo Usar padrões - Usando as configurações padrão. A edição cria configurações específicas do jogo. Salvar alterações Fechar AÇÃO - Para %1$s Pesquisar ações de rato ou teclas do teclado Limpar pesquisa Todas @@ -68,12 +59,9 @@ Teclado numérico Símbolos Movimento do rato - O arraste direto segue a posição do toque. O relativo segue o movimento do dedo e é útil quando um jogo centra o rato. - O movimento com o botão do meio sempre segue o movimento do dedo para evitar saltos do cursor. Direto Relativo Reconhecimento de gestos - Percorra esta distância antes que um gesto de dois ou três dedos se torne movimento de câmera ou zoom. Resposta visual Comportamento do botão do rato %1$d ms diff --git a/app/src/main/res/values-pt-rPT/strings.xml b/app/src/main/res/values-pt-rPT/strings.xml index 8c51b09c9e..fed2cf78ec 100644 --- a/app/src/main/res/values-pt-rPT/strings.xml +++ b/app/src/main/res/values-pt-rPT/strings.xml @@ -503,7 +503,9 @@ Eliminar este original? Este original de %1$s é de uma versão anterior de %2$s. O original da versão atual é sempre mantido. Nas Nightlies · %1$d - Atualize para listar os pacotes nas Nightlies. + Estável + Nightly + Atualize para listar os pacotes nas Nightlies e no DroidDeck. Nada de novo desde a última verificação. Importar .wcp Restaurar o original deste Proton @@ -581,6 +583,16 @@ Página anterior Página seguinte HUD de desempenho + Taxa de fotogramas + Temperatura da bateria + Gráfico de desempenho + Cor + Menta + Branco + Céu + Âmbar + Violeta + Opacidade Modo de escala Nitidez da escala Efeitos de ecrã @@ -1780,7 +1792,8 @@ O original da versão instalada é mantido: é o caminho de volta. Não guardado Original de %1$s de %2$s eliminado. - As transferências vêm apenas das versões Nightlies + As transferências vêm apenas das versões Nightlies e DroidDeck + A transferência falhou: esta versão nightly pode ter sido substituída por uma mais recente. Atualize a lista e tente novamente. Esta lista de pacotes é anterior às somas de verificação - atualize-a e tente novamente A soma de verificação não corresponde @@ -2036,6 +2049,9 @@ Última sincronização: %1$s Ainda não sincronizado %1$d ficheiros + Já está atualizado + Inicie sessão na loja para sincronizar os jogos guardados + Os jogos guardados não foram sincronizados instalado na sua biblioteca loja @@ -2338,7 +2354,7 @@ Concluído Não foi possível guardar o esquema tátil Esquema tátil guardado na Steam - Aplicação %1$d + Aplicação %1$s Etiqueta (opcional) Os ícones da Steam não foram encontrados @@ -2431,6 +2447,15 @@ Campo de visão do SteamVR Mais baixo aproxima o SteamVR e preenche os óculos; mais alto mostra mais à sua volta. A jogar em %1$s + Recentrar + Menu do SteamVR + Manípulos: mãos ⇄ jogo + Comandos: %1$s + Teclado + Menu da sessão + Parar o SteamVR + Brilho %1$d / %2$d + Bateria %1$d%% · %2$d °C Calibração do seguimento Reduz a deriva e alinha a referência de nível. A calibração guardada é aplicada a estes óculos. diff --git a/app/src/main/res/values-pt/gestures.xml b/app/src/main/res/values-pt/gestures.xml index 545700a318..c345617df7 100644 --- a/app/src/main/res/values-pt/gestures.xml +++ b/app/src/main/res/values-pt/gestures.xml @@ -18,8 +18,6 @@ Clicar uma vez Tempo para manter pressionado Intervalo de toque duplo - Aplica-se ao jogo atual - Configurações padrão para todos os jogos Restaurar as configurações originais de gestos Cancelar Escolher ação @@ -37,23 +35,16 @@ Roda do mouse Limiar dos gestos: %1$d px Mostrar gesto reconhecido - Controles de mouse e teclado organizados por gesto Um dedo Dois dedos Três dedos Opções - Escolha o que um toque, arraste ou toque mantido deve fazer. - Configure o movimento da câmera, o zoom e os cliques secundários. - Mantenha mais atalhos ao alcance dos dedos. - Ajuste o movimento, o reconhecimento e a resposta visual. Padrões Este jogo Usar padrões - Usando as configurações padrão. A edição cria configurações específicas do jogo. Salvar alterações Fechar AÇÃO - Para %1$s Pesquisar ações de mouse ou teclas do teclado Limpar pesquisa Todos @@ -68,12 +59,9 @@ Teclado numérico Símbolos Movimento do mouse - O arraste direto segue a posição do toque. O relativo segue o movimento do dedo e é útil quando um jogo centraliza o mouse. - O movimento com o botão do meio sempre segue o movimento do dedo para evitar saltos do cursor. Direto Relativo Reconhecimento de gestos - Percorra esta distância antes que um gesto de dois ou três dedos se torne movimento de câmera ou zoom. Resposta visual Comportamento do botão do mouse %1$d ms diff --git a/app/src/main/res/values-pt/strings.xml b/app/src/main/res/values-pt/strings.xml index 7c6f7f9661..37559d301f 100644 --- a/app/src/main/res/values-pt/strings.xml +++ b/app/src/main/res/values-pt/strings.xml @@ -503,7 +503,9 @@ Excluir este original? Este %1$s original é de uma versão anterior de %2$s. O original da versão atual é sempre mantido. Nas Nightlies · %1$d - Atualize para listar os pacotes nas Nightlies. + Estável + Nightly + Atualize para listar os pacotes nas Nightlies e no DroidDeck. Nada novo desde a última verificação. Importar .wcp Restaurar o original deste Proton @@ -581,6 +583,16 @@ Página anterior Próxima página HUD de desempenho + Taxa de quadros + Temperatura da bateria + Gráfico de desempenho + Cor + Menta + Branco + Céu + Âmbar + Violeta + Opacidade Modo de escala Nitidez da escala Efeitos de tela @@ -1780,7 +1792,8 @@ O original da versão instalada é mantido: é o caminho de volta. Não armazenado Original do %1$s de %2$s excluído. - Os downloads vêm só das versões Nightlies + Os downloads vêm só das versões Nightlies e DroidDeck + Falha no download: esta versão nightly pode ter sido substituída por uma mais nova. Atualize a lista e tente de novo. Esta lista de pacotes é anterior às somas de verificação - atualize-a e tente de novo A soma de verificação não confere @@ -2036,6 +2049,9 @@ Última sincronização: %1$s Ainda não sincronizado %1$d arquivos + Já está atualizado + Entre na loja para sincronizar os saves + Os saves não foram sincronizados instalado na sua biblioteca loja @@ -2338,7 +2354,7 @@ Concluído Não foi possível salvar o layout de toque Layout de toque salvo na Steam - App %1$d + App %1$s Rótulo (opcional) Os ícones da Steam não foram encontrados @@ -2431,6 +2447,15 @@ Campo de visão do SteamVR Menor aproxima o SteamVR e preenche os óculos; maior mostra mais ao seu redor. Jogando em %1$s + Recentralizar + Menu do SteamVR + Analógicos: mãos ⇄ jogo + Controles: %1$s + Teclado + Menu da sessão + Parar o SteamVR + Brilho %1$d / %2$d + Bateria %1$d%% · %2$d °C Calibração do rastreamento Reduz a deriva e alinha a referência de nível. A calibração salva é aplicada a estes óculos. diff --git a/app/src/main/res/values-ro/gestures.xml b/app/src/main/res/values-ro/gestures.xml index 6b7ab9bdee..6fb7b66fda 100644 --- a/app/src/main/res/values-ro/gestures.xml +++ b/app/src/main/res/values-ro/gestures.xml @@ -18,8 +18,6 @@ Un singur clic Durata până la menținere Intervalul atingerii duble - Se aplică jocului curent - Setări implicite pentru toate jocurile Restabilește setările originale ale gesturilor Anulează Alege acțiunea @@ -37,23 +35,16 @@ Rotița mouse-ului Pragul gesturilor: %1$d px Arată gestul recunoscut - Comenzi de mouse și tastatură organizate după gest Un deget Două degete Trei degete Opțiuni - Alege acțiunea unei atingeri, trageri sau mențineri. - Configurează deplasarea camerei, zoomul și clicurile secundare. - Păstrează scurtături suplimentare la îndemână. - Ajustează mișcarea, recunoașterea și feedbackul vizual. Valori implicite Acest joc Folosește valorile implicite - Se folosesc setările implicite. Editarea creează setări specifice jocului. Salvează modificările Închide ACȚIUNE - Pentru %1$s Caută acțiuni de mouse sau taste Șterge căutarea Toate @@ -68,12 +59,9 @@ Tastatură numerică Simboluri Mișcarea mouse-ului - Tragerea directă urmărește poziția atingerii. Cea relativă urmărește mișcarea degetului și este utilă când jocul recentrează mouse-ul. - Deplasarea cu butonul din mijloc urmărește întotdeauna mișcarea degetului pentru a evita salturile cursorului. Direct Relativă Recunoașterea gesturilor - Parcurge această distanță înainte ca un gest cu două sau trei degete să devină deplasare sau zoom. Feedback vizual Comportamentul butonului de mouse %1$d ms diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index c9e753866f..5ddf3f0a59 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -506,7 +506,9 @@ Ștergi acest original? Acest original %1$s este dintr-o versiune anterioară a %2$s. Originalul versiunii curente este păstrat mereu. Pe versiunile nightly · %1$d - Reîmprospătează pentru a lista pachetele de pe versiunile nightly. + Stabilă + Nightly + Reîmprospătează pentru a lista pachetele din Nightlies și DroidDeck. Nimic nou de la ultima verificare. Importă .wcp Restaurează originalul acestui Proton @@ -584,6 +586,16 @@ Pagina anterioară Pagina următoare HUD de performanță + Rată de cadre + Temperatură baterie + Grafic de performanță + Culoare + Mentă + Alb + Cer + Chihlimbariu + Violet + Opacitate Mod de scalare Claritatea scalării Efecte de ecran @@ -1791,7 +1803,8 @@ Originalul versiunii instalate este păstrat: este calea de revenire. Nesalvat S-a șters originalul %1$s al %2$s. - Descărcările vin doar din versiunile Nightlies + Descărcările vin doar din versiunile Nightlies și DroidDeck + Descărcarea a eșuat: această versiune nightly poate fi fost înlocuită cu una mai nouă. Reîmprospătează lista și încearcă din nou. Această listă de pachete e anterioară sumelor de control - reîmprospătează-o și încearcă din nou Sumă de control incorectă @@ -2047,6 +2060,9 @@ Ultima sincronizare %1$s Nesincronizat încă %1$d fișiere + Deja actualizat + Conectează-te la magazin pentru a sincroniza salvările + Salvările nu au fost sincronizate instalat în biblioteca ta magazin @@ -2352,7 +2368,7 @@ Terminat Aranjamentul tactil nu a putut fi salvat Aranjamentul tactil a fost salvat în Steam - Aplicația %1$d + Aplicația %1$s Etichetă (opțional) Pictogramele Steam nu au fost găsite @@ -2445,6 +2461,15 @@ Câmp vizual SteamVR Mai mic aduce SteamVR mai aproape și umple ochelarii; mai mare arată mai mult din jurul tău. Se joacă pe %1$s + Recentrează + Meniu SteamVR + Stickuri: mâini ⇄ joc + Controlere: %1$s + Tastatură + Meniul sesiunii + Oprește SteamVR + Luminozitate %1$d / %2$d + Baterie %1$d%% · %2$d °C Calibrarea urmăririi Reduce deriva și aliniază referința de nivel. Calibrarea salvată se aplică acestor ochelari. diff --git a/app/src/main/res/values-ru/gestures.xml b/app/src/main/res/values-ru/gestures.xml index 631b1fcfe4..bb758cb1b5 100644 --- a/app/src/main/res/values-ru/gestures.xml +++ b/app/src/main/res/values-ru/gestures.xml @@ -18,8 +18,6 @@ Один щелчок Задержка удержания Интервал двойного касания - Применяется к текущей игре - Настройки по умолчанию для всех игр Восстановить исходные настройки жестов Отмена Выберите действие @@ -37,23 +35,16 @@ Колесо мыши Порог жестов: %1$d пикс. Показывать распознанный жест - Управление мышью и клавиатурой по жестам Один палец Два пальца Три пальца Параметры - Выберите действие для касания, перетаскивания или удержания. - Настройте перемещение камеры, масштабирование и дополнительные щелчки. - Держите дополнительные команды под рукой. - Настройте движение, распознавание и визуальный отклик. По умолчанию Эта игра Использовать настройки по умолчанию - Используются настройки по умолчанию. Изменение создаст настройки для этой игры. Сохранить изменения Закрыть ДЕЙСТВИЕ - Для %1$s Поиск действий мыши или клавиш клавиатуры Очистить поиск Все @@ -68,12 +59,9 @@ Цифровой блок Символы Движение мыши - Прямое перетаскивание следует позиции касания. Относительное следует движению пальца и полезно, когда игра возвращает мышь в центр. - Панорамирование средней кнопкой всегда следует движению пальца, чтобы избежать скачков курсора. Прямой Относительное Распознавание жестов - Пройдите это расстояние, прежде чем жест двумя или тремя пальцами станет перемещением камеры или масштабированием. Визуальный отклик Поведение кнопки мыши %1$d мс diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 4af87d354a..83295afb97 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -307,6 +307,8 @@ Клиент Оверлей производительности Отключите, если игры вылетают или показывают черный экран в режиме Deck. Вступит в силу в следующей сессии. + Возвращаться в DroidDeck после игры + Когда игра, запущенная из DroidDeck или другого лаунчера, закрывается, Steam корректно завершает работу (сначала синхронизирует облачные сохранения), и вы возвращаетесь туда. Выкл.: остаётесь в Steam. Восстановить клиент Steam При следующем запуске Steam клиент будет скачан заново. Используйте, если Steam зависает на экране загрузки. Игры, вход и настройки сохраняются. Клиент Steam будет скачан заново при следующем запуске Steam. @@ -505,7 +507,9 @@ Удалить оригинальную версию? Эта оригинальная версия %1$s из более ранней сборки %2$s. Оригинальная версия текущей сборки всегда сохраняется. В Nightlies · %1$d - Обновите, чтобы увидеть пакеты в Nightlies. + Стабильная + Ночная + Обновите, чтобы увидеть пакеты в Nightlies и DroidDeck. С момента последней проверки нового нет. Импорт .wcp Восстановить оригинальные файлы этого Proton @@ -583,6 +587,16 @@ Предыдущая страница Следующая страница HUD производительности + Частота кадров + Температура батареи + График производительности + Цвет + Мята + Белый + Небесный + Янтарный + Фиолетовый + Непрозрачность Режим масштабирования Резкость масштабирования Экранные эффекты @@ -1809,7 +1823,8 @@ Оригинал установленной сборки сохраняется: через него можно вернуться. Не сохранено Удален оригинал %2$s из сборки %1$s. - Загрузки доступны только из выпусков Nightlies + Загрузки доступны только из выпусков Nightlies и DroidDeck + Не удалось загрузить: возможно, эта ночная сборка заменена более новой. Обновите список и повторите попытку. Этот список пакетов создан до появления контрольных сумм — обновите его и повторите попытку Контрольная сумма не совпадает @@ -2065,6 +2080,9 @@ Последняя синхронизация: %1$s Еще не синхронизировано Файлов: %1$d + Уже актуально + Войдите в магазин, чтобы синхронизировать сохранения + Сохранения не синхронизированы установлено в вашей библиотеке магазин @@ -2369,7 +2387,7 @@ Готово Не удалось сохранить сенсорную раскладку Сенсорная раскладка сохранена в Steam - Приложение %1$d + Приложение %1$s Подпись (необязательно) Значки Steam не найдены @@ -2464,6 +2482,15 @@ Поле зрения SteamVR Меньше — SteamVR ближе и заполняет очки; больше — шире обзор вокруг. Игра на %1$s + Перецентрировать + Меню SteamVR + Стики: руки ⇄ игра + Контроллеры: %1$s + Клавиатура + Меню сеанса + Остановить SteamVR + Яркость %1$d / %2$d + Батарея %1$d%% · %2$d °C Калибровка отслеживания Уменьшает дрейф и выравнивает опорный горизонт. Для этих очков применяется сохранённая калибровка. diff --git a/app/src/main/res/values-sv/gestures.xml b/app/src/main/res/values-sv/gestures.xml index a7475e8205..a860712b49 100644 --- a/app/src/main/res/values-sv/gestures.xml +++ b/app/src/main/res/values-sv/gestures.xml @@ -18,8 +18,6 @@ Klicka en gång Fördröjning före hållning Intervall för dubbeltryck - Gäller det aktuella spelet - Standardinställningar för alla spel Återställ de ursprungliga gestinställningarna Avbryt Välj åtgärd @@ -37,23 +35,16 @@ Mushjul Gesttröskel: %1$d px Visa identifierad gest - Mus- och tangentbordsstyrning ordnad efter gest Ett finger Två fingrar Tre fingrar Alternativ - Välj vad ett tryck, drag eller håll ska göra. - Ställ in kamerapanorering, zoom och sekundära klick. - Ha fler genvägar inom räckhåll. - Justera rörelse, identifiering och visuell återkoppling. Standardvärden Det här spelet Använd standardinställningar - Standardinställningar används. Redigering skapar inställningar för spelet. Spara ändringar Stäng ÅTGÄRD - För %1$s Sök efter musåtgärder eller tangenter Rensa sökning Alla @@ -68,12 +59,9 @@ Numeriskt tangentbord Symboler Musrörelse - Direkta drag följer pekpositionen. Relativa drag följer fingerrörelsen och är användbara när ett spel centrerar musen. - Panorering med musens mittknapp följer alltid fingerrörelsen för att undvika att pekaren hoppar. Direkt Relativ Gestidentifiering - Flytta fingrarna så här långt innan en gest med två eller tre fingrar blir panorering eller zoom. Visuell återkoppling Musknappens beteende %1$d ms diff --git a/app/src/main/res/values-sv/strings.xml b/app/src/main/res/values-sv/strings.xml index e740f9cb9b..3bab33523f 100644 --- a/app/src/main/res/values-sv/strings.xml +++ b/app/src/main/res/values-sv/strings.xml @@ -504,7 +504,9 @@ Ta bort det här originalet? Det här originalet av %1$s är från ett tidigare bygge av %2$s. Originalet från det aktuella bygget behålls alltid. I nattbyggena · %1$d - Uppdatera för att lista paket i nattbyggena. + Stabil + Nattbygge + Uppdatera för att lista paket i Nightlies och DroidDeck. Inget nytt sedan senaste kontrollen. Importera .wcp Återställ den här Protonens original @@ -582,6 +584,16 @@ Föregående sida Nästa sida Prestanda-HUD + Bildfrekvens + Batteritemperatur + Prestandagraf + Färg + Mint + Vit + Himmelsblå + Amber + Lila + Opacitet Skalningsläge Skalningsskärpa Skärmeffekter @@ -1770,7 +1782,8 @@ Den installerade versionens original behålls: det är vägen tillbaka. Inte sparad Tog bort %1$s-originalet av %2$s. - Nedladdningar kommer bara från Nightlies-utgåvorna + Nedladdningar kommer bara från Nightlies- och DroidDeck-utgåvorna + Nedladdningen misslyckades: det här nattbygget kan ha ersatts av ett nyare. Uppdatera listan och försök igen. Den här paketlistan är från innan kontrollsummor fanns - uppdatera den och försök igen Kontrollsumman stämmer inte @@ -2026,6 +2039,9 @@ Senast synkad %1$s Inte synkad än %1$d filer + Redan uppdaterat + Logga in i butiken för att synkronisera sparfiler + Sparfilerna synkroniserades inte installerat i ditt bibliotek butik @@ -2329,7 +2345,7 @@ Klar Det gick inte att spara pekskärmslayouten Pekskärmslayout sparad till Steam - App %1$d + App %1$s Etikett (valfritt) Steams ikoner hittades inte @@ -2420,6 +2436,15 @@ SteamVR-synfält Lägre för SteamVR närmare och fyller glasögonen; högre visar mer runt dig. Spelar på %1$s + Centrera om + SteamVR-meny + Spakar: händer ⇄ spel + Handkontroller: %1$s + Tangentbord + Sessionsmeny + Stoppa SteamVR + Ljusstyrka %1$d / %2$d + Batteri %1$d%% · %2$d °C Spårningskalibrering Minskar drift och justerar horisontreferensen. Sparad kalibrering används för de här glasögonen. diff --git a/app/src/main/res/values-th/gestures.xml b/app/src/main/res/values-th/gestures.xml index f625c607b7..0fedbbfa19 100644 --- a/app/src/main/res/values-th/gestures.xml +++ b/app/src/main/res/values-th/gestures.xml @@ -18,8 +18,6 @@ คลิกหนึ่งครั้ง ระยะเวลาก่อนกดค้าง ช่วงเวลาแตะสองครั้ง - ใช้กับเกมปัจจุบัน - การตั้งค่าเริ่มต้นสำหรับทุกเกม คืนค่าการตั้งค่าท่าทางเดิม ยกเลิก เลือกการกระทำ @@ -37,23 +35,16 @@ ล้อเมาส์ เกณฑ์ท่าทาง: %1$d พิกเซล แสดงท่าทางที่ตรวจพบ - การควบคุมเมาส์และแป้นพิมพ์แยกตามท่าทาง หนึ่งนิ้ว สองนิ้ว สามนิ้ว ตัวเลือก - เลือกการทำงานเมื่อแตะ ลาก หรือกดค้าง - ตั้งค่าการเลื่อนกล้อง การซูม และการคลิกรอง - เข้าถึงทางลัดเพิ่มเติมได้ง่าย - ปรับการเคลื่อนไหว การตรวจจับ และการตอบสนองทางภาพ ค่าเริ่มต้น เกมนี้ ใช้ค่าเริ่มต้น - กำลังใช้การตั้งค่าเริ่มต้น การแก้ไขจะสร้างการตั้งค่าเฉพาะเกม บันทึกการเปลี่ยนแปลง ปิด การกระทำ - สำหรับ %1$s ค้นหาการกระทำของเมาส์หรือปุ่มแป้นพิมพ์ ล้างการค้นหา ทั้งหมด @@ -68,12 +59,9 @@ แป้นตัวเลข สัญลักษณ์ การเคลื่อนที่ของเมาส์ - การลากแบบตรงจะตามตำแหน่งที่สัมผัส ส่วนการลากแบบสัมพัทธ์จะตามการเคลื่อนนิ้ว เหมาะเมื่อเกมนำเมาส์กลับไปตรงกลาง - การเลื่อนมุมมองด้วยปุ่มเมาส์กลางจะตามการเคลื่อนนิ้วเสมอเพื่อไม่ให้เคอร์เซอร์กระโดด โดยตรง สัมพัทธ์ การตรวจจับท่าทาง - เคลื่อนนิ้วตามระยะนี้ก่อนที่ท่าทางสองหรือสามนิ้วจะกลายเป็นการเลื่อนมุมมองหรือซูม การตอบสนองทางภาพ การทำงานของปุ่มเมาส์ %1$d มิลลิวินาที diff --git a/app/src/main/res/values-th/strings.xml b/app/src/main/res/values-th/strings.xml index 3a9157bb74..6210877843 100644 --- a/app/src/main/res/values-th/strings.xml +++ b/app/src/main/res/values-th/strings.xml @@ -502,7 +502,9 @@ ลบต้นฉบับนี้? ต้นฉบับ %1$s นี้มาจากบิลด์ก่อนหน้าของ %2$s ต้นฉบับของบิลด์ปัจจุบันจะถูกเก็บไว้เสมอ ใน Nightlies · %1$d - รีเฟรชเพื่อแสดงรายการแพ็กเกจใน Nightlies + เสถียร + Nightly + รีเฟรชเพื่อแสดงรายการแพ็กเกจใน Nightlies และ DroidDeck ไม่มีอะไรใหม่ตั้งแต่การตรวจสอบครั้งล่าสุด นำเข้า .wcp คืนค่าต้นฉบับของ Proton นี้ @@ -580,6 +582,16 @@ หน้าก่อนหน้า หน้าถัดไป HUD ประสิทธิภาพ + อัตราเฟรม + อุณหภูมิแบตเตอรี่ + กราฟประสิทธิภาพ + สี + มิ้นต์ + ขาว + ฟ้าสดใส + อำพัน + ม่วง + ความโปร่งใส โหมดการปรับขนาด ความคมชัดของการปรับขนาด เอฟเฟกต์หน้าจอ @@ -1749,7 +1761,8 @@ ต้นฉบับของบิลด์ที่ติดตั้งไว้ถูกเก็บไว้: นี่คือทางกลับ ไม่ได้บันทึกไว้ ลบต้นฉบับ %1$s ของ %2$s แล้ว - การดาวน์โหลดมาจากรุ่นที่เผยแพร่ใน Nightlies เท่านั้น + การดาวน์โหลดมาจากรุ่นที่เผยแพร่ใน Nightlies และ DroidDeck เท่านั้น + ดาวน์โหลดไม่สำเร็จ: บิลด์ nightly นี้อาจถูกแทนที่ด้วยบิลด์ที่ใหม่กว่า รีเฟรชรายการแล้วลองอีกครั้ง รายการแพ็กเกจนี้เก่ากว่าระบบค่าตรวจสอบ - รีเฟรชแล้วลองใหม่ ค่าตรวจสอบไม่ตรงกัน @@ -2005,6 +2018,9 @@ ซิงค์ล่าสุด %1$s ยังไม่ได้ซิงค์ %1$d ไฟล์ + อัปเดตแล้ว + ลงชื่อเข้าใช้ร้านค้าเพื่อซิงค์เซฟ + เซฟไม่ได้ซิงค์ ติดตั้งแล้ว อยู่ในไลบรารีของคุณ สโตร์ @@ -2306,7 +2322,7 @@ เสร็จสิ้น ไม่สามารถบันทึกเค้าโครงสัมผัสได้ บันทึกเค้าโครงสัมผัสลง Steam แล้ว - แอป %1$d + แอป %1$s ป้ายชื่อ (ไม่บังคับ) ไม่พบไอคอนของ Steam @@ -2395,6 +2411,15 @@ ขอบเขตการมองเห็นของ SteamVR ค่าต่ำจะดึง SteamVR เข้ามาใกล้และเต็มแว่นตา ค่าสูงจะแสดงสิ่งรอบตัวคุณได้มากขึ้น กำลังเล่นบน %1$s + จัดกึ่งกลางใหม่ + เมนู SteamVR + สติ๊ก: มือ ⇄ เกม + คอนโทรลเลอร์: %1$s + แป้นพิมพ์ + เมนูเซสชัน + หยุด SteamVR + ความสว่าง %1$d / %2$d + แบตเตอรี่ %1$d%% · %2$d °C การปรับเทียบการติดตาม ลดการดริฟต์และปรับแนวระดับอ้างอิงให้ตรง ใช้การปรับเทียบที่บันทึกไว้กับแว่นตานี้แล้ว diff --git a/app/src/main/res/values-tr/gestures.xml b/app/src/main/res/values-tr/gestures.xml index 53cc3ffb22..92ca99e015 100644 --- a/app/src/main/res/values-tr/gestures.xml +++ b/app/src/main/res/values-tr/gestures.xml @@ -18,8 +18,6 @@ Bir kez tıkla Basılı tutma gecikmesi Çift dokunma aralığı - Geçerli oyuna uygulanır - Tüm oyunlar için varsayılan ayarlar İlk hareket ayarlarına sıfırla İptal Eylem seç @@ -37,23 +35,16 @@ Fare tekerleği Hareket eşiği: %1$d piksel Algılanan hareketi göster - Hareketlere göre düzenlenmiş fare ve klavye kontrolleri Tek parmak İki parmak Üç parmak Seçenekler - Dokunma, sürükleme veya basılı tutmanın ne yapacağını seçin. - Kamera kaydırmasını, yakınlaştırmayı ve ikincil tıklamaları ayarlayın. - Ek kısayolları elinizin altında tutun. - Hareketi, algılamayı ve görsel geri bildirimi ayarlayın. Varsayılanlar Bu oyun Varsayılanları kullan - Varsayılan ayarlar kullanılıyor. Düzenleme, oyuna özel ayarlar oluşturur. Değişiklikleri kaydet Kapat EYLEM - %1$s için Fare eylemlerini veya klavye tuşlarını ara Aramayı temizle Tümü @@ -68,12 +59,9 @@ Sayısal tuş takımı Semboller Fare hareketi - Doğrudan sürükleme dokunma konumunu izler. Göreli sürükleme parmak hareketini izler ve oyun fareyi merkeze aldığında kullanışlıdır. - Orta fare düğmesiyle kaydırma, imlecin sıçramasını önlemek için her zaman parmak hareketini izler. Doğrudan Göreli Hareket algılama - İki veya üç parmak hareketinin kaydırma ya da yakınlaştırmaya dönüşmesi için bu mesafeyi aşın. Görsel geri bildirim Fare düğmesi davranışı %1$d ms diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml index 9e6b9ab15d..33107674ae 100644 --- a/app/src/main/res/values-tr/strings.xml +++ b/app/src/main/res/values-tr/strings.xml @@ -501,7 +501,9 @@ Bu orijinal silinsin mi? Bu %1$s orijinali, %2$s sürümünün önceki bir derlemesine ait. Geçerli derlemenin orijinali her zaman saklanır. Nightlies içinde · %1$d - Nightlies paketlerini listelemek için yenileyin. + Kararlı + Nightly + Nightlies ve DroidDeck paketlerini listelemek için yenileyin. Son kontrolden beri yeni bir şey yok. .wcp içe aktar Bu Proton\'un orijinalini geri yükle @@ -579,6 +581,16 @@ Önceki sayfa Sonraki sayfa Performans HUD\'u + Kare hızı + Pil sıcaklığı + Performans grafiği + Renk + Nane + Beyaz + Gök mavisi + Kehribar + Mor + Opaklık Ölçekleme modu Ölçekleme keskinliği Ekran efektleri @@ -593,7 +605,7 @@ Sahte HDR VR SteamVR - SteamVR\'ı başlat + SteamVR\'ye gir SteamVR denetleniyor… Bant giderme Bant giderme gücü @@ -614,9 +626,9 @@ Klavye Gecikme Düşük gecikmeli kumanda - Kumanda 250 Hz yerine 1000 Hz bildirir. Biraz daha fazla CPU. + Kumanda 250 Hz yerine 1000 Hz bildirir. CPU kullanımı biraz artar. Düşük gecikmeli dokunma - Dokunuşlar kare birleştirmeyi atlar; Steam dokunmatik kontrolleri 1000 Hz çalışır. Biraz daha fazla CPU. + Dokunmalar kare gruplamasını atlar; Steam dokunmatik kontrolleri 1000 Hz çalışır. CPU kullanımı biraz artar. PC klavyesi Android İkinci ekran @@ -1273,15 +1285,15 @@ %1$s %2$s sürümüne güncellendi. %1$s %2$s sürümüne güncellendi. Ekran sürücüsü, DroidDeck yeniden başlatıldıktan sonra uygulanır. Sürücü güncellemeleri oturum bitene kadar bekler. - %1$s %2$s, mobil veriyi ve pil tasarrufunu kapattığınızda indirilecek. - %1$s %2$s burada oturum başlatmadı, bu yüzden Otomatik çalışan sürücülerde kalıyor. - %1$s iki kez oturum başlatmadı, bu yüzden Otomatik çalışan sürücülere geri döndü. + %1$s %2$s, mobil veriden ve pil tasarrufundan çıkınca indirilecek. + %1$s %2$s burada oturum başlatamadı, bu yüzden Otomatik, oturum başlatabilen sürücülerde kalıyor. + %1$s iki kez oturum başlatamadı, bu yüzden Otomatik, sorunsuz çalışan önceki sürücülere döndü. %1$s %2$s sürümüne geçildi. %1$s %2$s sürümüne geçildi. Ekran sürücüsü, DroidDeck yeniden başlatıldıktan sonra uygulanır. Kullanılan: %1$s %2$s. Kullanılan: %1$s %2$s. Ekran sürücüsü, DroidDeck yeniden başlatıldıktan sonra uygulanır. - Pakette gelen Quest görüntü sürücüsü ve varsayılan çalışma zamanı kullanılıyor. - Pakette gelen Quest görüntü sürücüsü ve varsayılan çalışma zamanı kullanılıyor. Görüntü sürücüsü DroidDeck yeniden başladıktan sonra geçerli olur. + Pakete dahil Quest ekran sürücüsü ve çalışma zamanı varsayılanı kullanılıyor. + Pakete dahil Quest ekran sürücüsü ve çalışma zamanı varsayılanı kullanılıyor. Ekran sürücüsü DroidDeck yeniden başladıktan sonra uygulanır. Sürücü zip dosyası değil: ne AdrenoTools sürücüsü, ne -Linux Turnip ne de Android + Linux paketi İçe aktarma başarısız oldu: %1$s İçe aktarılan sürücü @@ -1703,7 +1715,7 @@ DroidDeck\'e geri dönmek için dokunun. Kablosuz hata ayıklamayı şimdi kapatabilirsiniz. Kablosuz hata ayıklama kurulumu durdu - İndirme başarısız oldu + İndirme başarısız İndirme boyutu yayınlanan APK ile eşleşmedi ve atıldı - yeniden deneyin İndirme, sağlama toplamıyla eşleşmedi ve atıldı - yeniden deneyin Güncelleme, %2$s değil %1$s Android paketi içindir @@ -1759,7 +1771,8 @@ Yüklü derlemenin orijinali saklanır: geri dönüş yolu budur. Saklanmıyor %2$s\'nin %1$s orijinali silindi. - İndirmeler yalnızca Nightlies yayınlarından gelir + İndirmeler yalnızca Nightlies ve DroidDeck yayınlarından gelir + İndirme başarısız: bu nightly derleme daha yenisiyle değiştirilmiş olabilir. Listeyi yenileyip tekrar deneyin. Bu paket listesi sağlama toplamlarından önceki bir tarihe ait - yenileyip yeniden deneyin Sağlama toplamı uyuşmuyor @@ -1801,7 +1814,7 @@ GitHub\'ın hız sınırına ulaşıldı - daha sonra yeniden deneyin GitHub HTTP %1$d yanıtı verdi - İndirme başarısız oldu + İndirme başarısız Bu sürücü listesi sağlama toplamlarından önceki bir tarihe ait - yenileyip yeniden deneyin Sağlama toplamı uyuşmuyor - indirme atıldı Bir AdrenoTools sürücüsü değil: %1$s @@ -2015,6 +2028,9 @@ Son eşitleme %1$s Henüz eşitlenmedi %1$d dosya + Zaten güncel + Kayıtları eşitlemek için mağazada oturum açın + Kayıtlar eşitlenmedi yüklü kütüphanenizde mağaza @@ -2161,14 +2177,14 @@ SteamGridDB\'de ara… SteamGridDB: %1$s Oyun ara - Diğer sonuçlar - Sonuç yok. - SteamGridDB bir API anahtarı gerektiriyor. Kendinizinkini Kurulum › Başlatıcı bölümüne ekleyin. - SteamGridDB API anahtarını kabul etmedi. Kurulum › Başlatıcı bölümünden denetleyin. - SteamGridDB şu anda istekleri sınırlıyor. Bir dakika sonra yeniden deneyin. - SteamGridDB\'ye ulaşılamadı. Bağlantınızı denetleyin. - SteamGridDB\'de bir sorun oluştu. Daha sonra yeniden deneyin. - SteamGridDB\'de bu oyun için sonuç yok. Aramayı deneyin. + Diğer eşleşmeler + Hiçbir şey bulunamadı. + SteamGridDB bir API anahtarı ister. Kurulum › Başlatıcı bölümüne kendi anahtarınızı ekleyin. + SteamGridDB API anahtarını kabul etmedi. Kurulum › Başlatıcı bölümünden kontrol edin. + SteamGridDB şu anda istekleri sınırlıyor. Bir dakika sonra tekrar deneyin. + SteamGridDB\'ye ulaşılamadı. Bağlantıyı kontrol edin. + SteamGridDB\'de bir sorun oluştu. Daha sonra tekrar deneyin. + SteamGridDB\'de bu oyun için eşleşme yok. Bir arama deneyin. %1$d oyun eklendi %1$d oyun eklendi @@ -2197,44 +2213,44 @@ Çalışma ortamı ve ekran sürücülerini ayrı ayrı %1$s kullanılsın mı? Sürücüler nasıl seçilir - Bu GPU için en iyi eşleşme, her zaman güncel + Bu GPU için en iyi çift, güncel tutulur Eşleşen çift Bir çift seçin; iki sürücüyü birden ayarlar - Serbest eşleştir - Görüntü ve çalışma zamanını ayrı ayrı seçin + Karıştır ve eşleştir + Ekran ve çalışma zamanını ayrı ayrı seçin Çift - Karışık - OTO + Karma + OTOMATİK ÇİFT PAKET - SEÇİLİ + SEÇİLEN GPU\'YA GÖRE VARSAYILAN - Şimdi çiziyor - Yeniden başlatma bekliyor · o zamana kadar %1$s çiziyor - Çalışıyor - Sonraki oturum · bu oturumda %1$s kalır - Ekranı çizer. Sonraki oturumdan itibaren geçerli. + Şu an çiziyor + Yeniden başlatma bekliyor · o zamana kadar %1$s çizer + Şu an çalışıyor + Sonraki oturum · bu oturum %1$s kullanmaya devam eder + Ekranı çizer. Sonraki oturumdan itibaren uygulanır. önceki sürücü - Görüntü sürücüsünü değiştirmek için yeniden başlatın. - Görüntü sürücüsünü değiştirmek için oturumu durdurup DroidDeck\'i yeniden başlatın. + Ekran sürücüsünü değiştirmek için yeniden başlatın. + Çalışan oturumu durdurun, sonra ekran sürücüsünü değiştirmek için DroidDeck\'i yeniden başlatın. Şimdi yeniden başlat Sonra - Otomatik, %1$s için bu çifti seçti - Otomatik, %1$s için yerleşik sürücüleri kullanıyor + Otomatik, %1$s cihazınız için bu çifti seçti + Otomatik, %1$s cihazınız için yerleşik sürücüleri kullanıyor %1$s ailesi için seçildi. Yeni sürümler arka planda kurulur. Bir çift seçin - Bir çift, görüntü sürücüsünü ve çalışma zamanı sürücüsünü birlikte ayarlar. + Bir çift, ekran ve çalışma zamanı sürücülerini birlikte ayarlar. Her sürücüyü seçin - Bir paket iki yuvayı da doldurur. Görüntü değişiklikleri yeniden başlatmadan sonra, çalışma zamanı değişiklikleri sonraki oturumdan itibaren geçerli olur. - Görüntü sürücüsünü değiştir + Bir paket iki yuvayı da doldurur. Ekran değişiklikleri yeniden başlatmadan sonra, çalışma zamanı değişiklikleri sonraki oturumda uygulanır. + Ekran sürücüsünü değiştir Çalışma zamanı sürücüsünü değiştir - OTOMATİK SEÇİMİ - Kurulu + OTOMATİK\'İN SEÇİMİ + Yüklü %1$s + %2$s %1$s · uygulamak için yeniden başlatın %1$s · yeniden başlatma bekliyor - Bu aygıt + Bu cihaz %1$s kaldırılsın mı? Tanılama Oynamaya hazır @@ -2246,11 +2262,11 @@ Görünüm Bu cihaz Kütüphane görselleri - İndirme + İndirmeler Kaynak Otomatik Doğrudan - Ayna + Yansı Özel önek Site Önek @@ -2315,7 +2331,7 @@ Bitti Dokunmatik düzen kaydedilemedi Dokunmatik düzen Steam\'e kaydedildi - Uygulama %1$d + Uygulama %1$s Etiket (isteğe bağlı) Steam\'in simgeleri bulunamadı @@ -2406,6 +2422,15 @@ SteamVR görüş alanı Düşük değer SteamVR\'ı yaklaştırır ve gözlüğü doldurur; yüksek değer çevrenizi daha çok gösterir. %1$s ile oynanıyor + Yeniden ortala + SteamVR menüsü + Çubuklar: eller ⇄ oyun + Kumandalar: %1$s + Klavye + Oturum menüsü + SteamVR’ı durdur + Parlaklık %1$d / %2$d + Pil %1$d%% · %2$d °C Takip kalibrasyonu Kaymayı azaltır ve yatay düzlem referansını hizalar. Kayıtlı kalibrasyon bu gözlüğe uygulanır. @@ -2509,7 +2534,7 @@ Yeterli boş alan yok: %1$s gerekli, yalnızca %2$s boş Yetersiz alan (%1$s boş, %2$s gerekli) Boş alan bilinmiyor - Resim konumu + Görüntü konumu Üst Alt Orta (varsayılan) @@ -2517,71 +2542,71 @@ Depolama ölçülüyor… İlk seferde birkaç saniye sürer. Dahili depolama - %2$s alanın %1$s kadarı kullanılıyor + %2$s içinde %1$s kullanıldı %1$s boş - DroidDeck %1$s yer kaplıyor. Ölçüm: %2$s. + DroidDeck %1$s kullanıyor. %2$s saatinde ölçüldü. yeniden ölçülüyor… Diğer Android uygulamaları - Şimdi boşaltılabilir - Kullanılmayan çalışma zamanları, kalıntılar, eski günlükler + Şimdi güvenle boşaltılabilir + Kullanılmayan çalışma zamanları, artıklar, eski günlükler Temizle… - Temizlemek veya kaldırmak için oturumu durdurun. Boyutlar görünmeye devam eder. + Bir şeyi temizlemek veya kaldırmak için oturumu durdurun. Boyutlar yine de gösterilir. Nereye gidiyor Steam oyunları Oyun verileri Önekler %1$s · atölye %2$s · gölgelendiriciler %3$s - Proton ve çalışma zamanları + Proton & çalışma zamanları %1$s kullanılmıyor - GOG, Epic ve diğer mağazalar - Mağazalar bölümünden kaldırın + GOG, Epic & diğer mağazalar + Bunları Mağazalar\'dan kaldırın Masaüstü uygulamaları Flatpak uygulamaları ve çalışma zamanları - Linux sistemi ve Steam istemcisi - Herhangi bir şeyin çalışması için gerekli + Linux sistemi & Steam istemcisi + Herhangi bir şeyi çalıştırmak için gerekli DroidDeck verileri - Eski oturum günlükleri %1$s · önbellek · sürücüler + Eski oturum günlükleri %1$s · önbellekler · sürücüler Oyunlar Oyun verileri - Proton ve çalışma zamanları + Proton & çalışma zamanları Diğer mağazalar Masaüstü uygulamaları Linux sistemi DroidDeck - Temizlik - Burada hiçbir şey kurulu oyunlara veya süren indirmelere dokunmaz. + Temizle + Burada hiçbir şey yüklü oyunlarınıza veya süren indirmelerinize dokunmaz. Şu anda temizlenecek bir şey yok. - Seçili: %1$s · %2$s → %3$s boş + Seçilen: %1$s · %2$s → %3$s boş Temizleniyor… %1$s boşalt %1$s boşaltıldı. - Kullanılmayan Steam çalışma zamanları ve Proton - Kaldırılmış oyunların kalıntıları - Kayıt içerebilecek kalıntılar + Kullanılmayan Steam çalışma zamanları ve Proton\'lar + Kaldırılan oyunlardan kalan artıklar + Kayıt tutabilecek artıklar Eski oturum günlükleri - Geçerli oturumun günlükleri tutulur - Hiçbir oyun kullanmıyor. Gerekirse Bileşenler bölümünden yeniden yükleyin. - Kurulu oyunların gölgelendirici önbelleği - Oynarken yeniden oluşur. Her oyunun ilk dakikaları yine takılır. + Geçerli oturumun günlükleri korunur + Hiçbir oyun buna ayarlı değil. Gerekirse Bileşenler\'den yeniden yükleyin. + Yüklü oyunların gölgelendirici önbellekleri + Oynadıkça yeniden oluşur. Her oyunun ilk dakikalarında yine takılma olur. Güvenli Kullanılmıyor Takılma - Kayıtları denetleyin + Kayıtları kontrol et Varsayılan Gerekli Kullanılmıyor Depolama - Verileriyle birlikte %1$s + %1$s, verileriyle birlikte En büyük En az oynanan SD kartta Burada oyun yok. - %1$s oynandı + Oynanma: %1$s Hiç oynanmadı Oyun %1$s · veri %2$s - Kaldır - Kaldırma, Steam\'in kaydetmesi için Steam penceresini açar. Bir oyunu SD karta taşımak için Steam › Ayarlar › Depolama yolunu kullanın. + Yüklemeyi kaldır + Yüklemeyi kaldırma, Steam\'in kendi iletişim kutusunu açar; böylece Steam kaydı tutar. Bir oyunu SD karta taşımak için Steam › Ayarlar › Depolama\'yı kullanın. %1$s kaldırılsın mı? - Steam açılır ve onay ister. Bu, oyunun %1$s alanını boşaltır. Kalıntıları temizleyene kadar önek kalır ve Steam Cloud kayıtları hesabınızda kalır. + Steam açılır ve onay ister. Bu, oyunun %1$s alanını boşaltır. Öneki, artıkları temizleyene kadar kalır ve Steam Cloud kayıtları hesabınızda durur. Steam\'i aç %1$s · %2$s kullanılmıyor Kullanılmayanları kaldır · %1$s @@ -2589,30 +2614,30 @@ Kullanılmıyor Kaldır %1$s kaldırılsın mı? - %1$s boşaltır. Bir oyun gerektirirse Steam yeniden indirir. + %1$s boşaltır. Bir oyun isterse Steam yeniden indirir. Linux x86 oyunları için gerekli (FEX) ARM64 Proton\'lar için gerekli - Oyunların istediği VC++ ve DirectX kurulumları + Oyunların istediği VC++ ve DirectX yükleyicileri Linux x86 oyunlarını çalıştırır Steam aracı DroidDeck oyunları bu çalışma zamanı olmadan çalıştırır - DroidDeck\'in çalıştıramadığı Proton x86 - Tüm oyunlar için varsayılan - Hiçbir oyun kullanmıyor - Steam ayarları okunamıyor, bu yüzden tutuluyor + x86 Proton, DroidDeck bunu çalıştıramaz + Her oyun için varsayılan + Hiçbir oyun buna ayarlı değil + Steam\'in ayarları okunamadı, bu yüzden korunuyor Depolama temizliğinin bitmesini bekleyin Yalnızca %1$s boş - Steam\'in güncellemeler ve gölgelendirici önbelleği için alana ihtiyacı var. 10 GB altında oyun güncellemeleri yarıda kalabilir. - %1$s risksiz boşaltılabilir. + Steam\'in güncellemeler ve gölgelendirici önbellekleri için yere ihtiyacı var. 10 GB\'ın altında oyun güncellemeleri yarıda başarısız olabilir. + %1$s güvenle boşaltılabilir. Yer aç Yine de oyna - %d kurulu - %d kurulu + %d yüklü + %d yüklü - %d SD kartta - %d SD kartta + SD kartta %d + SD kartta %d %d araç @@ -2623,15 +2648,15 @@ %d oyunun boş önek klasörleri ve gölgelendirici önbelleği - %d oyunun önekinde hâlâ dosyalar var; yerel kayıtlar da olabilir. Gerekirse önce bir kopya alın. - %d oyunun önekinde hâlâ dosyalar var; yerel kayıtlar da olabilir. Gerekirse önce bir kopya alın. + %d oyunun öneki hâlâ dosya içeriyor, bunlar yerel kayıtları da içerebilir. İsterseniz önce yedekleyin. + %d oyunun önekleri hâlâ dosya içeriyor, bunlar yerel kayıtları da içerebilir. İsterseniz önce yedekleyin. %d oyun %d oyun - DroidDeck varsayılan Proton - DroidDeck Proton 11 seçeneği + DroidDeck\'in varsayılan Proton\'u + DroidDeck\'in Proton 11 seçeneği %d oyun kullanıyor %d oyun kullanıyor @@ -2640,41 +2665,41 @@ Bileşenler Kullanılmayan bileşenler Orijinal %1$s · %2$s - %1$s boşaltır. Yalnızca artık kurulu olmayan bir Proton sürümünü geri yükler. - Denetlenmedi: bir Steam uygulamasının manifest dosyası okunamıyor, bu yüzden kaldırılmış oyunların önekleri okunana kadar kalır. + %1$s boşaltır. Yalnızca artık yüklü olmayan bir Proton sürümünü geri yükler. + Denetlenmedi: bir Steam uygulama manifesti okunamadı, bu yüzden kaldırılan oyunların önekleri manifest okunabilene kadar korunuyor. Tamamlanamadı: %1$s - Paylaşılan %1$s - Kurulu oyunlar + paylaşılan %1$s + Yüklü oyunlar Önek %1$s · gölgelendiriciler %2$s · atölye %3$s - Gölgelendiricileri sil - Kaldırılmış oyunlar + Gölgelendiricileri temizle + Kaldırılan oyunlar Steam uygulaması %1$d - Önekinde hâlâ dosyalar var; yerel kayıtlar da olabilir - Önekini (Wine) ve gölgelendirici önbelleğini siler (%1$s). Gerekli kayıtların önce bir kopyasını alın; Steam Cloud kayıtları hesabınızda kalır. - Tutulanlar - Steam dışı oyunlar ve ortak Steam öneki - Mağazaların veya elle eklenen oyunların önekleri + Öneki hâlâ dosya içeriyor, bunlar yerel kayıtları da içerebilir + Wine önekini ve gölgelendirici önbelleğini (%1$s) siler. Önce istediğiniz kayıtları yedekleyin; Steam Cloud kayıtları hesabınızda durur. + Korunan + Steam dışı oyunlar ve Steam\'in ortak öneki + Mağazalardan veya elle eklenen oyunların önekleri İndirilen paketler - Tutulan orijinaller + Kaydedilen orijinaller İndirilmiş bileşen paketi yok. Bir Proton veya oyun için seçili Hiçbir yerde seçili değil - Kurulu Proton\'ı geri yükler - Artık kurulu olmayan Proton sürümü + Yüklü Proton\'u geri yükler + Artık yüklü olmayan Proton sürümü Kullanımda - Kullanımdaki bileşenler kilitli kalır. Onları Bileşenler bölümünden seçin; burada kaldırdığınız paketler oradan yeniden indirilebilir. + Kullanımdaki bileşenler kilitli kalır. Bileşenler\'den seçin; burada kaldırılan her şey oradan yeniden indirilebilir. %1$s boşaltır. Kendi içe aktardığınız paketler yeniden indirilemez. - Flatpak uygulamaları için %1$s ve bunların paylaştıkları + Flatpak uygulamaları ve paylaştıkları şeyler için %1$s Uygulamalar Kurulu Flatpak uygulaması yok. - Uygulamaların paylaştıkları + Uygulamaların ortak kullandıkları Çalışma zamanları - Uygulamaların üzerinde çalıştığı kitaplıklar; kullanılmayanlar Kullanılmayanları kaldır ile gider + Uygulamaların üzerinde çalıştığı kütüphaneler; kullanılmayanlar Kullanılmayanları kaldır ile gider İndirme deposu - Flatpak object store ve önbelleğe alınmış indirmeler + Flatpak\'in nesne deposu ve önbelleğe alınmış indirmeler Kullanılmayanları kaldır - Kurulu hiçbir uygulamanın istemediği çalışma zamanlarını kaldırır ve Flatpak object store\'u temizler. Kurulu uygulamalar çalışmaya devam eder. - Uygulamayı (%1$s) ve başka kimsenin kullanmadığı çalışma zamanlarını kaldırır. Ev klasöründeki verileri kalır. + Kurulu hiçbir uygulamanın ihtiyaç duymadığı çalışma zamanlarını kaldırır ve Flatpak\'in nesne deposunu temizler. Kurulu uygulamalar çalışmaya devam eder. + Uygulamayı (%1$s) ve başka hiçbir şeyin kullanmadığı çalışma zamanlarını kaldırır. Ev klasörünüzdeki verileri kalır. %d paket %d paket diff --git a/app/src/main/res/values-uk/gestures.xml b/app/src/main/res/values-uk/gestures.xml index b5d4e1f414..7ed3663c62 100644 --- a/app/src/main/res/values-uk/gestures.xml +++ b/app/src/main/res/values-uk/gestures.xml @@ -18,8 +18,6 @@ Одне клацання Затримка утримання Інтервал подвійного дотику - Застосовується до поточної гри - Типові налаштування для всіх ігор Відновити початкові налаштування жестів Скасувати Виберіть дію @@ -37,23 +35,16 @@ Коліщатко миші Поріг жестів: %1$d пікс. Показувати розпізнаний жест - Керування мишею та клавіатурою за жестами Один палець Два пальці Три пальці Параметри - Виберіть дію для дотику, перетягування чи утримання. - Налаштуйте переміщення камери, масштабування та додаткові клацання. - Тримайте додаткові команди під рукою. - Налаштуйте рух, розпізнавання та візуальний відгук. Стандартні Ця гра Використовувати типові - Використовуються типові налаштування. Зміна створить налаштування для цієї гри. Зберегти зміни Закрити ДІЯ - Для %1$s Пошук дій миші або клавіш клавіатури Очистити пошук Усі @@ -68,12 +59,9 @@ Цифровий блок Символи Рух миші - Пряме перетягування відповідає положенню дотику. Відносне відповідає руху пальця й корисне, коли гра повертає мишу до центру. - Переміщення середньою кнопкою завжди відповідає руху пальця, щоб уникнути стрибків курсора. Пряме Відносний Розпізнавання жестів - Подолайте цю відстань, перш ніж жест двома чи трьома пальцями стане переміщенням камери або масштабуванням. Візуальний відгук Поведінка кнопки миші %1$d мс diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 931caa8ade..5bc3cd8f11 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -508,7 +508,9 @@ Видалити цей оригінал? Цей оригінал %1$s походить із попередньої збірки %2$s. Оригінал поточної збірки зберігається завжди. У нічних збірках · %1$d - Оновіть, щоб побачити пакети з нічних збірок. + Стабільна + Нічна + Оновіть, щоб побачити пакети з Nightlies і DroidDeck. Нічого нового з часу останньої перевірки. Імпортувати .wcp Відновити оригінал цього Proton @@ -586,6 +588,16 @@ Попередня сторінка Наступна сторінка HUD продуктивності + Частота кадрів + Температура батареї + Графік продуктивності + Колір + М\'ята + Білий + Небесний + Бурштиновий + Фіолетовий + Непрозорість Режим масштабування Чіткість масштабування Ефекти екрана @@ -1812,7 +1824,8 @@ Оригінал встановленої збірки збережено: це шлях назад. Не збережено Видалено оригінал %2$s зі збірки %1$s. - Завантаження надходять лише з випусків Nightlies + Завантаження надходять лише з випусків Nightlies і DroidDeck + Не вдалося завантажити: можливо, цю нічну збірку замінено новішою. Оновіть список і спробуйте ще раз. Цей список пакетів створено до появи контрольних сум - оновіть його і спробуйте ще раз Контрольна сума не збіглася @@ -2068,6 +2081,9 @@ Остання синхронізація %1$s Ще не синхронізовано %1$d файлів + Уже актуально + Увійдіть у магазин, щоб синхронізувати збереження + Збереження не синхронізовано встановлено у вашій бібліотеці магазин @@ -2375,7 +2391,7 @@ Готово Не вдалося зберегти сенсорну розкладку Сенсорну розкладку збережено в Steam - Застосунок %1$d + Застосунок %1$s Підпис (необов\'язково) Значки Steam не знайдено @@ -2470,6 +2486,15 @@ Поле зору SteamVR Нижче значення наближає SteamVR і заповнює окуляри; вище — показує більше навколо вас. Гра на %1$s + Перецентрувати + Меню SteamVR + Стіки: руки ⇄ гра + Контролери: %1$s + Клавіатура + Меню сеансу + Зупинити SteamVR + Яскравість %1$d / %2$d + Акумулятор %1$d%% · %2$d °C Калібрування відстеження Зменшує дрейф і вирівнює опорний горизонт. До цих окулярів застосовано збережене калібрування. diff --git a/app/src/main/res/values-vi/gestures.xml b/app/src/main/res/values-vi/gestures.xml index cf6f95eef3..90196d5ae7 100644 --- a/app/src/main/res/values-vi/gestures.xml +++ b/app/src/main/res/values-vi/gestures.xml @@ -18,8 +18,6 @@ Nhấp một lần Độ trễ nhấn giữ Khoảng thời gian chạm hai lần - Áp dụng cho trò chơi hiện tại - Cài đặt mặc định cho mọi trò chơi Khôi phục cài đặt cử chỉ ban đầu Hủy Chọn thao tác @@ -37,23 +35,16 @@ Con lăn chuột Ngưỡng cử chỉ: %1$d px Hiện cử chỉ đã nhận dạng - Điều khiển chuột và bàn phím theo từng cử chỉ Một ngón tay Hai ngón tay Ba ngón tay Tùy chọn - Chọn thao tác cho chạm, kéo hoặc giữ. - Cấu hình di chuyển camera, thu phóng và nhấp phụ. - Giữ các phím tắt bổ sung trong tầm tay. - Tinh chỉnh chuyển động, nhận dạng và phản hồi hình ảnh. Mặc định Trò chơi này Dùng mặc định - Đang dùng cài đặt mặc định. Chỉnh sửa sẽ tạo cài đặt riêng cho trò chơi. Lưu thay đổi Đóng THAO TÁC - Cho %1$s Tìm thao tác chuột hoặc phím bàn phím Xóa tìm kiếm Tất cả @@ -68,12 +59,9 @@ Bàn phím số Ký hiệu Chuyển động chuột - Kéo trực tiếp theo vị trí chạm. Kéo tương đối theo chuyển động ngón tay, hữu ích khi trò chơi đưa chuột về giữa. - Di chuyển bằng nút chuột giữa luôn theo chuyển động ngón tay để tránh con trỏ nhảy vị trí. Trực tiếp Tương đối Nhận dạng cử chỉ - Di chuyển khoảng cách này trước khi cử chỉ hai hoặc ba ngón tay trở thành di chuyển camera hoặc thu phóng. Phản hồi hình ảnh Cách hoạt động của nút chuột %1$d ms diff --git a/app/src/main/res/values-vi/strings.xml b/app/src/main/res/values-vi/strings.xml index d636a67ead..874e91cd7b 100644 --- a/app/src/main/res/values-vi/strings.xml +++ b/app/src/main/res/values-vi/strings.xml @@ -502,7 +502,9 @@ Xóa bản gốc này? Bản gốc %1$s này là từ một build trước của %2$s. Bản gốc của build hiện tại luôn được giữ lại. Trên Nightlies · %1$d - Làm mới để liệt kê các gói trên Nightlies. + Ổn định + Nightly + Làm mới để liệt kê các gói trên Nightlies và DroidDeck. Không có gì mới từ lần kiểm tra trước. Nhập tệp .wcp Khôi phục bản gốc của Proton này @@ -580,6 +582,16 @@ Trang trước Trang sau HUD hiệu năng + Tốc độ khung hình + Nhiệt độ pin + Biểu đồ hiệu năng + Màu + Bạc hà + Trắng + Xanh da trời + Hổ phách + Tím + Độ mờ Chế độ chia tỷ lệ Độ sắc nét khi chia tỷ lệ Hiệu ứng màn hình @@ -1749,7 +1761,8 @@ Bản gốc của build đã cài được giữ lại: đó là đường quay về. Chưa được lưu Đã xóa bản gốc %1$s của %2$s. - Lượt tải chỉ đến từ các bản phát hành Nightlies + Lượt tải chỉ đến từ các bản phát hành Nightlies và DroidDeck + Tải xuống thất bại: bản nightly này có thể đã được thay bằng bản mới hơn. Hãy làm mới danh sách và thử lại. Danh sách gói này có trước checksum - hãy làm mới và thử lại Checksum không khớp @@ -2005,6 +2018,9 @@ Đồng bộ lần cuối %1$s Chưa đồng bộ %1$d tệp + Đã cập nhật + Đăng nhập cửa hàng để đồng bộ bản lưu + Bản lưu chưa được đồng bộ đã cài trong thư viện của bạn cửa hàng @@ -2306,7 +2322,7 @@ Xong Không thể lưu bố cục chạm Đã lưu bố cục chạm vào Steam - Ứng dụng %1$d + Ứng dụng %1$s Nhãn (không bắt buộc) Không tìm thấy biểu tượng của Steam @@ -2395,6 +2411,15 @@ Trường nhìn của SteamVR Thấp hơn sẽ đưa SteamVR lại gần và lấp đầy kính; cao hơn cho thấy nhiều hơn xung quanh bạn. Đang chơi trên %1$s + Căn giữa lại + Menu SteamVR + Cần: tay ⇄ trò chơi + Tay cầm: %1$s + Bàn phím + Menu phiên + Dừng SteamVR + Độ sáng %1$d / %2$d + Pin %1$d%% · %2$d °C Hiệu chỉnh theo dõi Giảm hiện tượng trôi và căn lại mốc thăng bằng. Hiệu chỉnh đã lưu đang được áp dụng cho kính này. diff --git a/app/src/main/res/values-zh-rCN/gestures.xml b/app/src/main/res/values-zh-rCN/gestures.xml index c3b12946c2..18f6c00ce4 100644 --- a/app/src/main/res/values-zh-rCN/gestures.xml +++ b/app/src/main/res/values-zh-rCN/gestures.xml @@ -18,8 +18,6 @@ 单击一次 按住延迟 双击间隔 - 应用于当前游戏 - 所有游戏的默认设置 恢复初始手势设置 取消 选择操作 @@ -37,23 +35,16 @@ 鼠标滚轮 手势阈值:%1$d 像素 显示识别到的手势 - 按手势分类的鼠标和键盘控制 单指 双指 三指 选项 - 选择点按、拖动或按住时执行的操作。 - 配置镜头平移、缩放和辅助单击。 - 随手使用更多快捷操作。 - 调整移动、识别和视觉反馈。 默认值 此游戏 使用默认设置 - 正在使用默认设置。修改后会创建此游戏的专用设置。 保存更改 关闭 操作 - 用于%1$s 搜索鼠标操作或键盘按键 清除搜索 全部 @@ -68,12 +59,9 @@ 数字小键盘 符号 鼠标移动 - 直接拖动跟随触摸位置。相对拖动跟随手指移动,适用于会将鼠标重置到中心的游戏。 - 鼠标中键平移始终跟随手指移动,以避免光标跳动。 直接 相对 手势识别 - 双指或三指移动达到此距离后,才会识别为平移或缩放。 视觉反馈 鼠标按钮行为 %1$d 毫秒 diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index f513e51a9f..960fdd825b 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -310,6 +310,8 @@ 客户端 性能覆盖层 若游戏在 Deck 模式下崩溃或黑屏,请关闭性能覆盖层。将在下次会话生效。 + 游戏结束后返回 DroidDeck + 从 DroidDeck 或其他启动器启动的游戏关闭后,Steam 会正常退出(先完成云存档同步),并返回启动位置。关闭:留在 Steam 中。 修复 Steam 客户端 下次启动 Steam 时重新下载 Steam 客户端。如果 Steam 一直停在加载画面,请使用此项。游戏、登录信息和设置都会保留。 下次启动 Steam 时将重新下载 Steam 客户端。 @@ -502,7 +504,9 @@ 删除此原件? 此 %1$s 原件来自 %2$s 的较早构建。当前构建的原件始终保留。 在 Nightlies 上 · %1$d - 刷新以列出 Nightlies 上的软件包。 + 稳定版 + 每夜版 + 刷新以列出 Nightlies 和 DroidDeck 上的软件包。 自上次检查以来没有新内容。 导入 .wcp 还原此 Proton 的原件 @@ -580,6 +584,16 @@ 上一页 下一页 性能 HUD + 帧率 + 电池温度 + 性能图表 + 颜色 + 薄荷绿 + 白色 + 天蓝 + 琥珀 + 紫罗兰 + 不透明度 缩放模式 缩放锐度 屏幕效果 @@ -1825,7 +1839,8 @@ 已安装构建的原件会保留:它是还原的途径。 未存储 已删除 %2$s 的 %1$s 原件。 - 只能从 Nightlies 发布版本下载 + 只能从 Nightlies 和 DroidDeck 发布版本下载 + 下载失败:此每夜版本可能已被更新的版本替换。请刷新列表后重试。 此软件包列表早于校验和功能 — 请刷新后重试 校验和不匹配 @@ -2081,6 +2096,9 @@ 上次同步:%1$s 尚未同步 %1$d 个文件 + 已是最新 + 登录商店以同步存档 + 存档未同步 已安装 在你的库中 商店 @@ -2306,7 +2324,7 @@ 完成 无法保存触控布局 触控布局已保存到 Steam - 应用 %1$d + 应用 %1$s 标签(可选) 未找到 Steam 的图标 @@ -2395,6 +2413,15 @@ SteamVR 视场角 调低让 SteamVR 更近并填满眼镜;调高可看到更多周围内容。 正在 %1$s 上游玩 + 重新居中 + SteamVR 菜单 + 摇杆:双手 ⇄ 游戏 + 控制器:%1$s + 键盘 + 会话菜单 + 停止 SteamVR + 亮度 %1$d / %2$d + 电池 %1$d%% · %2$d °C 追踪校准 减少漂移并对齐水平基准。 这副眼镜已应用保存的校准。 diff --git a/app/src/main/res/values-zh-rHK/gestures.xml b/app/src/main/res/values-zh-rHK/gestures.xml index 50d00f4108..45bbcc062f 100644 --- a/app/src/main/res/values-zh-rHK/gestures.xml +++ b/app/src/main/res/values-zh-rHK/gestures.xml @@ -18,8 +18,6 @@ 按一下 按住延遲 連點兩下間隔 - 套用至目前遊戲 - 所有遊戲的預設設定 還原初始手勢設定 取消 選擇動作 @@ -37,23 +35,16 @@ 滑鼠滾輪 手勢閾值:%1$d 像素 顯示辨識到的手勢 - 依手勢分類的滑鼠與鍵盤控制 單指 雙指 三指 選項 - 選擇點按、拖曳或按住時執行的動作。 - 設定鏡頭平移、縮放與輔助點擊。 - 隨手使用更多快捷操作。 - 調整移動、辨識與視覺回饋。 預設值 此遊戲 使用預設值 - 正在使用預設設定。修改後會建立此遊戲的專用設定。 儲存變更 關閉 動作 - 用於%1$s 搜尋滑鼠動作或鍵盤按鍵 清除搜尋 全部 @@ -68,12 +59,9 @@ 數字鍵盤 符號 滑鼠移動 - 直接拖曳會跟隨觸控位置。相對拖曳會跟隨手指移動,適用於會將滑鼠重設到中央的遊戲。 - 滑鼠中鍵平移一律跟隨手指移動,以避免游標跳動。 直接 相對 手勢辨識 - 雙指或三指移動達到此距離後,才會辨識為平移或縮放。 視覺回饋 滑鼠按鈕行為 %1$d 毫秒 diff --git a/app/src/main/res/values-zh-rHK/strings.xml b/app/src/main/res/values-zh-rHK/strings.xml index 10cc860e71..00c99dd55d 100644 --- a/app/src/main/res/values-zh-rHK/strings.xml +++ b/app/src/main/res/values-zh-rHK/strings.xml @@ -310,6 +310,8 @@ 用戶端 效能疊加層 如果在 Deck 模式下遊戲當機或黑畫面,請關閉此項。下次會話生效。 + 遊戲結束後返回 DroidDeck + 從 DroidDeck 或其他啟動器啟動的遊戲關閉後,Steam 會正常退出(先完成雲端存檔同步),並返回啟動位置。關閉:留在 Steam 中。 修復 Steam 用戶端 下次啟動 Steam 時重新下載 Steam 用戶端。如果 Steam 一直停留在載入畫面,請使用此功能。遊戲、登入資料和設定都會保留。 下次啟動 Steam 時會重新下載 Steam 用戶端。 @@ -502,7 +504,9 @@ 刪除此原始版本? 此 %1$s 原始版本來自 %2$s 的較早版本。目前版本的原始版本一定會保留。 Nightlies · %1$d - 重新整理以列出 Nightlies 中的軟件包。 + 穩定版 + 每夜版 + 重新整理以列出 Nightlies 及 DroidDeck 中的軟件包。 自上次檢查以來沒有新內容。 匯入 .wcp 還原此 Proton 的原始版本 @@ -580,6 +584,16 @@ 上一頁 下一頁 效能 HUD + 幀率 + 電池溫度 + 效能圖表 + 顏色 + 薄荷綠 + 白色 + 天藍 + 琥珀色 + 紫羅蘭 + 不透明度 縮放模式 縮放銳利度 畫面效果 @@ -1749,7 +1763,8 @@ 已安裝版本的原始版本會保留,以便還原。 未儲存 已刪除 %2$s 的 %1$s 原始版本。 - 只會從 Nightlies 發佈版本下載 + 只會從 Nightlies 及 DroidDeck 發佈版本下載 + 下載失敗:此每夜版本可能已被較新的版本取代。請重新整理清單後再試。 此軟件包清單早於校驗和推出 - 請重新整理後再試一次 校驗和不符 @@ -2005,6 +2020,9 @@ 上次同步:%1$s 尚未同步 %1$d 個檔案 + 已是最新 + 登入商店以同步存檔 + 存檔未同步 已安裝 在你的收藏庫中 商店 @@ -2306,7 +2324,7 @@ 完成 無法儲存觸控佈局 觸控佈局已儲存至 Steam - 應用程式 %1$d + 應用程式 %1$s 標籤(選用) 找不到 Steam 的圖示 @@ -2395,6 +2413,15 @@ SteamVR 視場角 調低令 SteamVR 更近並填滿眼鏡;調高可看到更多周圍內容。 正在 %1$s 上遊玩 + 重新置中 + SteamVR 選單 + 搖桿:雙手 ⇄ 遊戲 + 控制器:%1$s + 鍵盤 + 工作階段選單 + 停止 SteamVR + 亮度 %1$d / %2$d + 電池 %1$d%% · %2$d °C 追蹤校準 減少漂移並對齊水平基準。 這副眼鏡已套用儲存的校準。 diff --git a/app/src/main/res/values-zh-rTW/gestures.xml b/app/src/main/res/values-zh-rTW/gestures.xml index b51d68f112..464f94d88e 100644 --- a/app/src/main/res/values-zh-rTW/gestures.xml +++ b/app/src/main/res/values-zh-rTW/gestures.xml @@ -18,8 +18,6 @@ 按一下 按住延遲 連點兩下間隔 - 套用至目前遊戲 - 所有遊戲的預設設定 還原初始手勢設定 取消 選擇動作 @@ -37,23 +35,16 @@ 滑鼠滾輪 手勢閾值:%1$d 像素 顯示辨識到的手勢 - 依手勢分類的滑鼠與鍵盤控制 單指 雙指 三指 選項 - 選擇點按、拖曳或按住時執行的動作。 - 設定鏡頭平移、縮放與輔助點擊。 - 隨手使用更多快捷操作。 - 調整移動、辨識與視覺回饋。 預設值 此遊戲 使用預設值 - 正在使用預設設定。修改後會建立此遊戲的專用設定。 儲存變更 關閉 動作 - 用於%1$s 搜尋滑鼠動作或鍵盤按鍵 清除搜尋 全部 @@ -68,12 +59,9 @@ 數字鍵盤 符號 滑鼠移動 - 直接拖曳會跟隨觸控位置。相對拖曳會跟隨手指移動,適用於會將滑鼠重設到中央的遊戲。 - 滑鼠中鍵平移一律跟隨手指移動,以避免游標跳動。 直接 相對 手勢辨識 - 雙指或三指移動達到此距離後,才會辨識為平移或縮放。 視覺回饋 滑鼠按鈕行為 %1$d 毫秒 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index e11242c246..941437a04d 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -310,6 +310,8 @@ 用戶端 效能重疊層 如果 Deck 模式下遊戲崩潰或黑畫面,請關閉此項。下次工作階段生效。 + 遊戲結束後返回 DroidDeck + 從 DroidDeck 或其他啟動器啟動的遊戲關閉後,Steam 會正常退出(先完成雲端存檔同步),並返回啟動位置。關閉:留在 Steam 中。 修復 Steam 用戶端 下次啟動 Steam 時重新下載 Steam 用戶端。如果 Steam 一直停在載入畫面,請使用此功能。遊戲、登入狀態和設定都會保留。 下次啟動 Steam 時會重新下載 Steam 用戶端。 @@ -502,7 +504,9 @@ 刪除這個原始版本? 這個 %1$s 原始版本來自 %2$s 的較早組建。目前組建的原始版本一律會保留。 Nightlies 中 · %1$d - 重新整理以列出 Nightlies 中的套件。 + 穩定版 + 每夜版 + 重新整理以列出 Nightlies 和 DroidDeck 中的套件。 自上次檢查以來沒有新內容。 匯入 .wcp 還原此 Proton 的原始檔案 @@ -580,6 +584,16 @@ 上一頁 下一頁 效能 HUD + 幀率 + 電池溫度 + 效能圖表 + 顏色 + 薄荷綠 + 白色 + 天藍 + 琥珀 + 紫羅蘭 + 不透明度 縮放模式 縮放銳利度 畫面效果 @@ -1749,7 +1763,8 @@ 已安裝組建的原始版本會保留,以便還原。 未儲存 已刪除 %2$s 來自 %1$s 的原始版本。 - 只會從 Nightlies 發行版本下載 + 只會從 Nightlies 和 DroidDeck 發行版本下載 + 下載失敗:此每夜版本可能已被較新的版本取代。請重新整理清單後再試一次。 此套件清單早於校驗碼機制 - 請重新整理後再試一次 校驗碼不符 @@ -2005,6 +2020,9 @@ 上次同步:%1$s 尚未同步 %1$d 個檔案 + 已是最新 + 登入商店以同步存檔 + 存檔未同步 已安裝 在你的收藏庫中 商店 @@ -2306,7 +2324,7 @@ 完成 無法儲存觸控版面配置 觸控版面配置已儲存至 Steam - 應用程式 %1$d + 應用程式 %1$s 標籤(選用) 找不到 Steam 的圖示 @@ -2395,6 +2413,15 @@ SteamVR 視野角度 調低讓 SteamVR 更近並填滿眼鏡;調高可看到更多周圍內容。 正在 %1$s 上遊玩 + 重新置中 + SteamVR 選單 + 搖桿:雙手 ⇄ 遊戲 + 控制器:%1$s + 鍵盤 + 工作階段選單 + 停止 SteamVR + 亮度 %1$d / %2$d + 電池 %1$d%% · %2$d °C 追蹤校正 減少漂移並對齊水平基準。 這副眼鏡已套用儲存的校正資料。 diff --git a/app/src/main/res/values/gestures.xml b/app/src/main/res/values/gestures.xml index 0a7c5c25bf..7c91324223 100644 --- a/app/src/main/res/values/gestures.xml +++ b/app/src/main/res/values/gestures.xml @@ -18,8 +18,6 @@ Click once Hold delay Double-tap interval - Applies to the current game - Default settings for all games Reset to original gesture settings Cancel Choose action @@ -37,23 +35,16 @@ Mouse wheel Gesture threshold: %1$d px Show recognized gesture - Mouse and keyboard controls, organized by gesture One finger Two fingers Three fingers Options - Choose what a tap, drag, or hold should do. - Configure camera panning, zoom, and secondary clicks. - Keep extra shortcuts within reach. - Fine-tune movement, recognition, and visual feedback. Defaults This game Use defaults - Using default settings. Editing creates a game override. Save changes Close ACTION - For %1$s Search mouse actions or keyboard keys Clear search All @@ -68,12 +59,9 @@ Numpad Symbols Mouse movement - Direct drags follow your touch position. Relative drags follow finger movement, useful when a game recenters the mouse. - Middle mouse pan always follows finger movement to avoid cursor jumps. Direct Relative Gesture recognition - Move this far before a two- or three-finger gesture becomes a pan or zoom. Visual feedback Mouse button behavior %1$d ms diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index ebef852975..f9bce69777 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -308,6 +308,12 @@ Up to date · %1$s Loader Install latest + Update Channel + Which Decky Loader releases to install. Decky\'s own updater uses the same channel. + Stable + Prerelease + Testing + Could not save the Decky update channel Starts with Steam. While on, other apps on this device may be able to control Steam. Off. Steam\'s remote debugging port stays closed. Uninstall Decky Loader? @@ -315,6 +321,8 @@ Client Performance overlay Turn off if games crash or go black in Deck mode. Applies next session. + Return to DroidDeck after a game + When a game you started from DroidDeck or another launcher closes, Steam exits cleanly (cloud saves finish first) and you go back there. Off: stay in Steam. Repair Steam client Downloads the Steam client again the next time Steam starts. Use it if Steam stays on its loading screen. Games, sign-in and settings are kept. The Steam client will be downloaded again the next time Steam starts. @@ -509,7 +517,9 @@ Delete this original? This %1$s original is from an earlier build of %2$s. The current build\'s original is always kept. On the Nightlies · %1$d - Refresh to list packages on the Nightlies. + Stable + Nightly + Refresh to list packages on the Nightlies and DroidDeck releases. Nothing new since the last check. Import .wcp Restore this Proton\'s original @@ -587,6 +597,16 @@ Previous page Next page Performance HUD + Frame rate + Battery temperature + Performance graph + Color + Mint + White + Sky + Amber + Violet + Opacity Scaling mode Scaling sharpness Screen effects @@ -1404,6 +1424,13 @@ Install a plugin ZIP for the next Steam session. Downloading… Install from ZIP + Third-Party Plugin Installation + The Decky Loader team has not reviewed this plugin. It may contain malware, such as software to steal your Steam account or harm your device. By installing this plugin, you agree you have assumed all risks to your device. + Continue + + Please wait %1$d second + Please wait %1$d seconds + Games Audio & Video Graphics @@ -1821,7 +1848,8 @@ The installed build\'s original is kept: it is the way back. Not stored Deleted the %1$s original of %2$s. - Downloads come only from the Nightlies releases + Downloads come only from the Nightlies and DroidDeck releases + Download failed: this nightly may have been replaced by a newer build. Refresh the list and try again. This package list predates checksums - refresh it and try again Checksum mismatch @@ -2079,6 +2107,9 @@ Last sync %1$s Not synced yet %1$d files + Already up to date + Sign in to the store to sync saves + Saves were not synced installed in your library store @@ -2167,6 +2198,9 @@ Download manager Downloads at a time Install to + Game language + GOG and Epic install this language. System follows the app language. + System Install %1$s: Internal %1$s free @@ -2395,7 +2429,7 @@ Done Could not save the touch layout Touch layout saved to Steam - App %1$d + App %1$s Label (optional) Steam\'s icons were not found @@ -2492,6 +2526,22 @@ Automatic keeps this 2D game fixed in view. Choose Virtual screen in Display to use head tracking. Head tracking applies to a virtual screen or a running SteamVR game. Device + Controllers + SteamVR controllers + Game pad in VR + The two VR hands your controller plays as. Changes apply right away, also while SteamVR runs. Joy-Cons and tracked hands still take over their side. + Regular game pad + Valve Index controllers + Meta Quest 3 controllers + HTC Vive wands + Sticks start by + Press both sticks in together during VR to switch. + Moving you in the game + Moving the hands + Buttons + Triggers are triggers, bumpers grip, A/B and X/Y are each hand\'s face buttons, stick clicks click the thumbsticks, Guide opens the SteamVR menu. D-pad up and down move the hands closer or farther. + The sticks are trackpads; A/X or a stick click presses them. Triggers are triggers, bumpers grip, Start and Select are menu, Guide opens the SteamVR menu. + No VR hands. Games that support a game pad, and the SteamVR menu, get your controller as usual. Brightness Volume Sunblock @@ -2509,6 +2559,15 @@ SteamVR field of view Lower brings SteamVR closer and fills the glasses; higher shows more around you. Playing on %1$s + Recenter + SteamVR menu + Sticks: hands ⇄ game + Controllers: %1$s + Keyboard + Session menu + Stop SteamVR + Brightness %1$d / %2$d + Battery %1$d%% · %2$d °C Tracking calibration Reduce drift and align the level reference. Saved calibration is applied to these glasses. diff --git a/app/src/test/java/com/droiddeck/launcher/core/AddonPackTest.kt b/app/src/test/java/com/droiddeck/launcher/core/AddonPackTest.kt new file mode 100644 index 0000000000..9172c5a5c3 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/core/AddonPackTest.kt @@ -0,0 +1,57 @@ +package com.droiddeck.launcher.core + +import android.content.Context +import androidx.test.core.app.ApplicationProvider +import java.io.File +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner + +@RunWith(RobolectricTestRunner::class) +class AddonPackTest { + private val context: Context = ApplicationProvider.getApplicationContext() + private val root get() = File(context.filesDir, "addons/sample") + + @Before fun clean() { + root.deleteRecursively() + } + + private fun installed(version: String, complete: Boolean = true, modified: Long = 1_000L): File = + File(root, version).apply { + mkdirs() + File(this, "tool").writeText("x") + if (complete) File(this, AddonPack.COMPLETE).writeText(version) + setLastModified(modified) + } + + @Test fun unpinnedLocalBuildReusesTheNewestCompletePack() { + installed("a".repeat(64), modified = 1_000L) + installed("b".repeat(64), modified = 2_000L) + installed("c".repeat(64), complete = false, modified = 3_000L) + val pack = AddonPack("sample", "", 0L, listOf("tool"), reuseDeviceCopy = true) + + assertTrue(pack.installed(context)) + assertEquals("b".repeat(64), pack.dir(context).name) + } + + @Test fun unpinnedLocalBuildWithNothingInstalledHasNoPack() { + assertFalse(AddonPack("sample", "", 0L, listOf("tool"), reuseDeviceCopy = true).installed(context)) + } + + @Test fun pinnedBuildIgnoresOtherInstalledVersions() { + installed("b".repeat(64)) + val pack = AddonPack("sample", "a".repeat(64), 1L, listOf("tool")) + + assertFalse(pack.installed(context)) + assertEquals("a".repeat(64), pack.dir(context).name) + } + + @Test fun ciBuildWithoutAPinNeverReuses() { + installed("b".repeat(64)) + assertFalse(AddonPack("sample", "", 0L, listOf("tool"), reuseDeviceCopy = false).installed(context)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/core/DownloaderResumeTest.kt b/app/src/test/java/com/droiddeck/launcher/core/DownloaderResumeTest.kt index a3faef0701..73fd0161c6 100644 --- a/app/src/test/java/com/droiddeck/launcher/core/DownloaderResumeTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/core/DownloaderResumeTest.kt @@ -167,4 +167,10 @@ class DownloaderResumeTest { assertEquals(listOf(catalog), DownloadSource.candidates(catalog)) } + + @Test fun withoutADigestOnlyTheOriginalUrlIsTried() { + val url = "https://github.com/owner/repo/releases/download/v1/app.AppImage" + assertEquals(listOf(url), Downloader.sources(url, null)) + assertEquals(DownloadSource.candidates(url), Downloader.sources(url, "a".repeat(64))) + } } diff --git a/app/src/test/java/com/droiddeck/launcher/core/LogRedactorTest.kt b/app/src/test/java/com/droiddeck/launcher/core/LogRedactorTest.kt index ddeb3ac1fa..a67093e935 100644 --- a/app/src/test/java/com/droiddeck/launcher/core/LogRedactorTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/core/LogRedactorTest.kt @@ -37,6 +37,83 @@ class LogRedactorTest { assertEquals("login ok", LogRedactor.redact("login someone@example.com ok")) } + @Test fun onlyLoaderDiagnosticsKeepHidlSharedLibraryNames() { + val library = "android.hardware.graphics.mapper@4.0.so" + val line = "dlopen failed: library \"$library\" not found" + val pathLine = "dlopen failed: library \"/vendor/lib64/hw/$library\" not found" + + assertEquals(line, LogRedactor.redact(line)) + assertEquals(line, LogRedactor.redactForShare(line)) + assertEquals(pathLine, LogRedactor.redact(pathLine)) + assertEquals(pathLine, LogRedactor.redactForShare(pathLine)) + } + + @Test fun privacyRulesOverrideTheHidlSharedLibraryException() { + val library = "android.hardware.graphics.mapper@4.0.so" + assertEquals("token=", LogRedactor.redact("token=$library")) + assertEquals("username=", LogRedactor.redact("username=$library")) + assertEquals("{\"password\":\"\"}", LogRedactor.redact("{\"password\":\"$library\"}")) + assertEquals("{\"password\":\"\"}", LogRedactor.redactForShare("{\"password\":\"$library\"}")) + assertEquals("{\"password\":\"\"}", LogRedactor.redact("{\"password\":\"don't-use-$library\"}")) + assertEquals("{\"password\":\"\"}", LogRedactor.redactForShare("{\"password\":\"don't-use-$library\"}")) + + val mixed = "dlopen failed: library \"$library\" not found; token=abcdef123456; contact=alice!$library; {\"password\":\"library \\\"$library\\\" not found\"}" + val expected = "dlopen failed: library \"$library\" not found; token=; contact=alice!; {\"password\":\"\"}" + assertEquals(expected, LogRedactor.redact(mixed)) + assertEquals(expected, LogRedactor.redactForShare(mixed)) + + val root = java.nio.file.Files.createTempDirectory("hidl-redactor").toFile() + val users = java.io.File(root, "loginusers.vdf") + users.writeText("\"AccountName\" \"$library\"") + try { + LogRedactor.learnAccounts(users) + assertEquals("", LogRedactor.redact(library)) + } finally { + LogRedactor.learnAccounts() + root.deleteRecursively() + } + } + + @Test fun hidlSharedLibraryNamesAreRedactedOutsideLoaderDiagnostics() { + val library = "android.hardware.graphics.mapper@4.0.so" + + assertEquals("", LogRedactor.redact(library)) + assertEquals("", LogRedactor.redactForShare(library)) + assertEquals("/vendor/lib64/hw/", LogRedactor.redact("/vendor/lib64/hw/$library")) + for (punctuation in listOf("!", "#", "~", "/", "=")) { + val expected = "contact=alice$punctuation" + assertEquals(expected, LogRedactor.redact("contact=alice$punctuation$library")) + assertEquals(expected, LogRedactor.redactForShare("contact=alice$punctuation$library")) + } + assertEquals("", LogRedactor.redact("$library.evil")) + assertEquals("", LogRedactor.redact("someone@company.so")) + assertEquals("", LogRedactor.redact("not$library")) + assertEquals("_debug", LogRedactor.redact("${library}_debug")) + assertEquals(".1", LogRedactor.redact("${library}.1")) + assertEquals("@attacker", LogRedactor.redact("${library}@attacker")) + assertEquals("", LogRedactor.redact("android.hardware.graphics.mapper@4.0.software")) + assertEquals("", LogRedactor.redact("android.hardware.graphics.mapper@4.0.so.evil")) + } + + @Test fun loaderContextRequiresExactWordsAndABoundedAndroidPath() { + val library = "android.hardware.graphics.mapper@4.0.so" + val valid = "library \"/system/lib64/$library\" not found: needed by app" + assertEquals(valid, LogRedactor.redact(valid)) + assertEquals(valid, LogRedactor.redactForShare(valid)) + for (line in listOf( + "not_library \"$library\" not found", + "library \"$library\" not found_suffix", + "library \"/home/user/$library\" not found", + "library \"relative/$library\" not found", + "library \"/vendor/invalid!/$library\" not found", + "library \"/vendor/" + "a/".repeat(2050) + "$library\" not found", + )) { + val expected = line.replace(library, "") + assertEquals(expected, LogRedactor.redact(line)) + assertEquals(expected, LogRedactor.redactForShare(line)) + } + } + @Test fun clockTimeIsNotAnAddress() { val line = "[2026-09-27 10:03:05] Startup" assertEquals(line, LogRedactor.redact(line)) diff --git a/app/src/test/java/com/droiddeck/launcher/frontend/StoreGameArtTest.kt b/app/src/test/java/com/droiddeck/launcher/frontend/StoreGameArtTest.kt index a0e84775d8..448cca6a88 100644 --- a/app/src/test/java/com/droiddeck/launcher/frontend/StoreGameArtTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/frontend/StoreGameArtTest.kt @@ -36,7 +36,7 @@ class StoreGameArtTest { } @Test fun anArtChoiceOnAStoreGameIsKeptShownAndResetsWithoutTouchingItsTitle() { - for ((store, id, title) in listOf(Triple(Store.GOG, "1207658924", "Heroes III"), Triple(Store.EPIC, "abc", "Celeste"), Triple(Store.AMAZON, "amzn1.x", "Yakuza 0"))) { + for ((store, id, title) in listOf(Triple(Store.GOG, "1207658924", "Heroes III"), Triple(Store.EPIC, "abc", "Celeste"), Triple(Store.AMAZON, "amzn1.x", "Yakuza 0"), Triple(Store.XBOX, "9NBLGGH4X1", "Forza Horizon"), Triple(Store.ITCH, "12345", "Night in the Woods"))) { val folder = install(store, id, title) val image = File(tmp.root, "$id.png").apply { writeBytes(ByteArray(9) { 1 }) } val option = AddedGameArt.Option(AddedGameArt.FILE, image.path, image.path) diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesRenderingTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesRenderingTest.kt index 401d247013..51d9aa7b72 100644 --- a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesRenderingTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesRenderingTest.kt @@ -5,6 +5,14 @@ import org.junit.Assert.* import org.junit.Test class GlassesRenderingTest { + @Test fun modelTwoDRatesLimitChoicesAndSavedRatesFallBackToAnOfferedOne() { + val rokid = GlassesState(displayId = 2, width = 1920, height = 1080, hz = 60f, rates2d = listOf(60, 120)) + assertEquals(listOf(60, 120), GlassesRendering.refreshRates(GlassesSettings(), rokid)) + assertEquals(60, GlassesRendering.outputHz(GlassesSettings(refreshHz = 90), rokid)) + assertEquals(120, GlassesRendering.outputHz(GlassesSettings(refreshHz = 120), rokid)) + assertEquals(listOf(60, 90, 120), GlassesRendering.refreshRates(GlassesSettings(), rokid.copy(rates2d = listOf(60, 90, 120)))) + } + private val ultra = GlassesState( model = "VITURE Luma Ultra", connected = true, controllable = true, displayId = 2, width = 1920, height = 1200, diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesUsbTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesUsbTest.kt index d4ee21f796..ae274cece1 100644 --- a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesUsbTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesUsbTest.kt @@ -209,6 +209,14 @@ class GlassesUsbTest { assertEquals(null, Glasses.deviceModel(device(0x043e, 0x1234, "XREAL 1S"))) } + @Test fun rokidMaxRoutesThroughItsOwnModelAndSharedVendorIdNeedsTheName() { + val max = Glasses.deviceModel(device(0x162f, 0x04d2, "Rokid Max")) + assertTrue(max is RokidModel) + assertEquals("Rokid Max", max?.name) + assertEquals(null, Glasses.deviceModel(device(0x162f, 0x04d2, "Generic HID"))) + assertTrue(Glasses.isGlassesDisplayName("Rokid Max")) + } + private fun device(pid: Int, vid: Int = VitureProtocol.VENDOR_ID, name: String = "VITURE device"): UsbDevice = ReflectionHelpers.callConstructor( UsbDevice::class.java, from(String::class.java, "/dev/bus/usb/$pid"), diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/RokidProtocolTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/RokidProtocolTest.kt new file mode 100644 index 0000000000..c2cf38e33b --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/RokidProtocolTest.kt @@ -0,0 +1,94 @@ +package com.droiddeck.launcher.glasses + +import com.droiddeck.launcher.gpu.HeadPose +import org.junit.Assert.* +import org.junit.Test +import java.nio.ByteBuffer +import java.nio.ByteOrder + +class RokidProtocolTest { + private fun hex(s: String) = s.chunked(2).map { it.toInt(16).toByte() }.toByteArray() + private fun matrix(q: FloatArray) = HeadPose.fromGlasses(q[0], q[1], q[2], q[3]) + + @Test fun identityRequiresRokidProductString() { + assertEquals("Rokid Max", RokidModel.model(0x04d2, 0x162f, "Rokid Max")?.name) + assertEquals("Rokid Air", RokidModel.model(0x04d2, 0x162f, "Rokid Air")?.name) + assertNull(RokidModel.model(0x04d2, 0x162f, "USB Keyboard")) + assertNull(RokidModel.model(0x04d2, 0x162f, null)) + assertNull(RokidModel.model(0x04d2, 0x1234, "Rokid Max")) + assertTrue(RokidModel.isDisplay("Rokid Max")) + } + + @Test fun maxModesFollowRefreshAndStereoResolution() { + val max = RokidModel.model(0x04d2, 0x162f, "Rokid Max")!! + assertEquals(RokidModel.MODE_2D_60, max.mode(60, false, null)) + assertEquals(RokidModel.MODE_2D_120, max.mode(120, false, null)) + assertEquals(RokidModel.MODE_2D_60, max.mode(90, false, null)) + assertEquals(listOf(60, 120), max.rates2d) + assertEquals(RokidModel.MODE_SBS_1200_60, max.mode(60, true, null)) + assertEquals(RokidModel.MODE_SBS_1200_90, max.mode(90, true, null)) + assertEquals(RokidModel.MODE_SBS_1080_60, max.mode(90, true, GlassesResolution(1920, 1080))) + assertTrue(max.sbs90) + assertFalse(max.hasSunblock) + } + + @Test fun airStaysOnSixtyHertzModes() { + val air = RokidModel.model(0x04d2, 0x162f, "Rokid Air")!! + assertEquals(RokidModel.MODE_2D_60, air.mode(120, false, null)) + assertEquals(RokidModel.MODE_SBS_1080_60, air.mode(90, true, null)) + assertFalse(air.sbs90) + assertEquals(listOf(60), air.rates2d) + } + + @Test fun brightnessStepsRoundTripTheDevicePercent() { + assertEquals(8, RokidModel.brightnessStep(80)) + assertEquals(10, RokidModel.brightnessStep(100)) + assertEquals(3, RokidModel.brightnessStep(32)) + assertEquals(0, RokidModel.brightnessStep(0)) + assertEquals(30, RokidModel.brightnessRaw(3)) + assertEquals(100, RokidModel.brightnessRaw(12)) + } + + @Test fun capturedMaxCombinedReportParsesAccelGyroAndBrightness() { + val packet = hex("11d09b3e3700000000bb9eb03f9147f0c06e86c340306a43bc9c227b3ad3e6aebb000055c29a99abc1cdccfac10000000000000000000000000000503c000000") + val sample = RokidProtocol.Parser().parse(packet)!! + assertEquals(0x373e9bd0L, sample.timeNs) + assertEquals(1.380f, sample.accel.x, 0.001f) + assertEquals(-7.509f, sample.accel.y, 0.001f) + assertEquals(6.110f, sample.accel.z, 0.001f) + assertEquals(-0.0119f, sample.gyro.x, 0.0001f) + assertEquals(80, sample.brightness) + assertNull(RokidProtocol.Parser().parse(packet.copyOf(32))) + } + + @Test fun airSeparateReportsPairOnSharedTimestamp() { + fun report(type: Int, time: Long, v: Vec3) = ByteBuffer.allocate(64).order(ByteOrder.LITTLE_ENDIAN).apply { + put(0, 4); put(1, type.toByte()); putLong(9, time) + putFloat(21, v.x); putFloat(25, v.y); putFloat(29, v.z) + }.array() + val parser = RokidProtocol.Parser() + assertNull(parser.parse(report(1, 500, Vec3(0f, 9.81f, 0f)))) + val sample = parser.parse(report(2, 500, Vec3(0.1f, 0f, 0f)))!! + assertEquals(500_000L, sample.timeNs) + assertEquals(9.81f, sample.accel.y, 0f) + assertEquals(0.1f, sample.gyro.x, 0f) + assertNull(sample.brightness) + assertNull(parser.parse(report(2, 600, Vec3(0f, 0f, 0f)))) + } + + @Test fun capturedRestingGravityStartsUpright() { + val pose = ImuFusion().update(1_000_000, Vec3(0.01f, 9.58f, -2.20f), Vec3(0f, 0f, 0f))!! + assertTrue(kotlin.math.abs(pose[3]) > 0.97f) + } + + @Test fun capturedLeftTurnSignLooksLeft() { + val fusion = ImuFusion() + val first = matrix(fusion.update(1_000_000, Vec3(0f, 9.81f, 0f), Vec3(0f, 0f, 0f))!!) + var last = FloatArray(4) + repeat(1000) { + last = fusion.update((it + 2) * 1_000_000L, Vec3(0f, 9.81f, 0f), Vec3(0f, (Math.PI / 6).toFloat(), 0f))!! + } + val view = HeadPose.relative(HeadPose.recenter(first), matrix(last)) + assertArrayEquals(floatArrayOf(-0.5f, 0f, -0.8660254f), HeadPose.apply(view, floatArrayOf(0f, 0f, -1f)), 0.01f) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/gpu/AutoDriverTrialTest.kt b/app/src/test/java/com/droiddeck/launcher/gpu/AutoDriverTrialTest.kt index d38d96b3f9..c9a0fa7b4c 100644 --- a/app/src/test/java/com/droiddeck/launcher/gpu/AutoDriverTrialTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/gpu/AutoDriverTrialTest.kt @@ -62,4 +62,25 @@ class AutoDriverTrialTest { assertNull(AutoDriverTrial.rollbackDue(context)) assertEquals("banner@r5", AutoDriverTrial.current(context)?.release) } + + @Test fun displayDriverCrashesBeforeSessionStartStillCount() { + AutoDriverTrial.displayStarting(context, "new-display") + assertNull(AutoDriverTrial.rollbackDue(context)) + AutoDriverTrial.displayStarting(context, "new-display") + assertEquals(2, AutoDriverTrial.rollbackDue(context)?.starts) + } + + @Test fun aNormalStartIsCountedOnce() { + AutoDriverTrial.displayStarting(context, "new-display") + AutoDriverTrial.sessionStarting(context, "new-display", "new-linux") + assertEquals(1, AutoDriverTrial.current(context)?.starts) + AutoDriverTrial.displayStarting(context, "other-display") + assertEquals(1, AutoDriverTrial.current(context)?.starts) + } + + @Test fun aTrialStartedBeforeDisplayCountingStillRollsBackOnTheNextCrash() { + AutoDriverTrial.sessionStarting(context, "new-display", "new-linux") + AutoDriverTrial.displayStarting(context, "new-display") + assertEquals(2, AutoDriverTrial.rollbackDue(context)?.starts) + } } diff --git a/app/src/test/java/com/droiddeck/launcher/input/VrControllersTest.kt b/app/src/test/java/com/droiddeck/launcher/input/VrControllersTest.kt new file mode 100644 index 0000000000..3f74f20fcb --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/input/VrControllersTest.kt @@ -0,0 +1,13 @@ +package com.droiddeck.launcher.input + +import org.junit.Assert.assertEquals +import org.junit.Test + +class VrControllersTest { + @Test fun encodesTheKeysTheSteamVrDriverReads() { + assertEquals("emulate=index\nsticks=game\n", VrControllers.encode(VrControllers.Settings())) + assertEquals("emulate=touch\nsticks=hands\n", + VrControllers.encode(VrControllers.Settings(VrControllers.Emulate.TOUCH, sticksMoveHands = true))) + assertEquals(listOf("off", "index", "touch", "vive"), VrControllers.Emulate.entries.map { it.key }) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/runtime/BwrapSpawnerTest.kt b/app/src/test/java/com/droiddeck/launcher/runtime/BwrapSpawnerTest.kt index e1e6827ab1..2cb5e5edd6 100644 --- a/app/src/test/java/com/droiddeck/launcher/runtime/BwrapSpawnerTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/runtime/BwrapSpawnerTest.kt @@ -118,4 +118,31 @@ class BwrapSpawnerPlanTest { assertEquals("/app", plan.cwd) assertEquals("org.example.Game", plan.env["FLATPAK_ID"]) } + + @Test fun zypakLaunchesTheBrowserWithoutItsSandbox() { + val context = RuntimeEnvironment.getApplication() + val app = File(runtime, "app").apply { File(this, "bin").mkdirs() } + File(app, "bin/zypak-wrapper.sh").writeText("#!/usr/bin/bash\nexec zypak-helper host - \"\$@\"\n") + Files.createSymbolicLink(File(app, "bin/zypak-wrapper").toPath(), java.nio.file.Paths.get("/app/bin/zypak-wrapper.sh")) + val plan = BwrapSpawner.plan(context, request( + op("t" to "bind", "src" to "/runtime-files/app", "dest" to "/app", "ro" to true), + ), dir) + + val shim = plan.binds.single { it.guest == "/app/bin/zypak-wrapper.sh" } + assertTrue(shim.host.startsWith(dir.path)) + assertTrue(File(shim.host).readText().contains("exec \"\$program\" --no-sandbox \"\$@\"")) + assertFalse(plan.binds.any { it.guest == "/app/bin/zypak-wrapper" }) + assertTrue(File(app, "bin/zypak-wrapper.sh").readText().contains("zypak-helper")) + } + + @Test fun appsWithoutZypakKeepTheirFiles() { + val context = RuntimeEnvironment.getApplication() + File(runtime, "app/bin").mkdirs() + val plan = BwrapSpawner.plan(context, request( + op("t" to "bind", "src" to "/runtime-files/app", "dest" to "/app", "ro" to true), + ), dir) + + assertFalse(plan.binds.any { it.guest.startsWith("/app/bin/") }) + assertFalse(File(dir, "zypak-wrapper").exists()) + } } diff --git a/app/src/test/java/com/droiddeck/launcher/runtime/DeckyChannelTest.kt b/app/src/test/java/com/droiddeck/launcher/runtime/DeckyChannelTest.kt new file mode 100644 index 0000000000..025fc6379a --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/runtime/DeckyChannelTest.kt @@ -0,0 +1,32 @@ +package com.droiddeck.launcher.runtime + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test + +class DeckyChannelTest { + private fun release(tag: String, prerelease: Boolean) = + DeckyManager.Release(tag, prerelease, "PluginLoader-arm64", "https://example.invalid/$tag", null, null, 1, 183) + + @Test fun stableSkipsPrereleasesAndPrereleaseTakesTheNewestTag() { + val pre = release("v3.4.0-pre1", true) + val stable = release("v3.3.0", false) + val channels = DeckyManager.ReleaseChannels(listOf(stable), listOf(pre), listOf(pre, stable)) + + assertEquals("v3.3.0", DeckyManager.latest(channels, DeckyManager.BRANCH_STABLE)?.tag) + assertEquals("v3.4.0-pre1", DeckyManager.latest(channels, DeckyManager.BRANCH_PRERELEASE)?.tag) + } + + @Test fun prereleaseFollowsAStableThatShippedAfterTheLastPrerelease() { + val stable = release("v3.3.0", false) + val pre = release("v3.3.0-pre1", true) + val channels = DeckyManager.ReleaseChannels(listOf(stable), listOf(pre), listOf(stable, pre)) + + assertEquals("v3.3.0", DeckyManager.latest(channels, DeckyManager.BRANCH_PRERELEASE)?.tag) + } + + @Test fun stableHasNothingWhenOnlyPrereleasesExist() { + val pre = release("v3.4.0-pre1", true) + assertNull(DeckyManager.latest(DeckyManager.ReleaseChannels(emptyList(), listOf(pre), listOf(pre)), DeckyManager.BRANCH_STABLE)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/runtime/DesktopRemovalTest.kt b/app/src/test/java/com/droiddeck/launcher/runtime/DesktopRemovalTest.kt new file mode 100644 index 0000000000..250a655354 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/runtime/DesktopRemovalTest.kt @@ -0,0 +1,122 @@ +package com.droiddeck.launcher.runtime + +import android.content.ContextWrapper +import com.droiddeck.launcher.BuildConfig +import java.io.File +import java.nio.file.Files +import java.nio.file.Paths +import java.util.zip.GZIPInputStream +import org.junit.After +import org.junit.Assert.* +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment + +@RunWith(RobolectricTestRunner::class) +class DesktopRemovalTest { + private val dir = Files.createTempDirectory("desktop-removal").toFile() + private val context = object : ContextWrapper(RuntimeEnvironment.getApplication()) { + override fun getFilesDir() = File(dir, "files").apply { mkdirs() } + override fun getCacheDir() = File(dir, "cache").apply { mkdirs() } + } + private val root = LinuxRuntime.rootDir(context).apply { mkdirs() } + private val marker = File(root, ".droiddeck-pkg-${DesktopCatalog.DESKTOP_ID}") + private val journal = File(root, marker.name + ".installing") + private val pending = File(root, DesktopRemoval.PENDING) + private val listener = LinuxRuntimeInstaller.ProgressListener { _, _ -> } + + @After fun cleanup() { dir.deleteRecursively() } + + @Test fun removesTheDesktopWhileKeepingRuntimeAppsGamesAndSettings() { + val desktop = desktopFiles() + marker.writeText(BuildConfig.DESKTOP_KDE_TAG) + val keep = listOf("root/.local/share/Steam/steamapps/common/game/data", "root/.config/kdeglobals", + "opt/appimages/custom.AppImage", "usr/lib/shared.so", "usr/share/plasma/custom") + .map { file(it, "keep") } + + assertTrue(DesktopCatalog.desktopPresent(context)) + assertNull(DesktopCatalog.removeDesktop(context, listener)) + + assertFalse(Files.exists(desktop.toPath(), java.nio.file.LinkOption.NOFOLLOW_LINKS)) + keep.forEach { assertEquals("keep", it.readText()) } + assertFalse(DesktopCatalog.desktopPresent(context)) + assertFalse(DesktopCatalog.desktopInstalled(context)) + } + + @Test fun interruptedInstallCanBeRemovedWithoutBeingResumedAtTheNextLaunch() { + desktopFiles() + val entry = DesktopCatalog.desktopEntry(context) + journal.writeText(DesktopCatalog.entryJson(entry).toString()) + val download = File(context.cacheDir, "pkg-${entry.id}-${entry.sha256.take(12)}.download").apply { writeText("download") } + val resume = File(download.path + ".resume.properties").apply { writeText("resume") } + val unrelated = file(".droiddeck-pkg-emulators.installing", DesktopCatalog.entryJson(DesktopCatalog.Entry( + "emulators", "Emulators", 1, "1", "tar", "https://example.invalid/emulators", "a".repeat(64), 1L, "", "", "", + )).toString()) + assertTrue(DesktopCatalog.desktopPresent(context)) + + assertNotNull(DesktopCatalog.removeDesktop(context) { _, _ -> error("interrupted") }) + assertTrue(pending.exists()) + assertTrue(journal.exists()) + assertTrue(DesktopCatalog.desktopPresent(context)) + assertNull(DesktopCatalog.removeDesktop(context, listener)) + + assertFalse(journal.exists()) + assertFalse(pending.exists()) + assertFalse(download.exists()) + assertFalse(resume.exists()) + assertFalse(DesktopCatalog.desktopPresent(context)) + assertEquals(listOf("emulators"), DesktopCatalog.interrupted(context).map { it.id }) + assertTrue(unrelated.exists()) + } + + @Test fun refusesUnknownDesktopVersionsAndMissingRuntimeOwnershipBeforeDeletingAnything() { + val desktop = desktopFiles() + marker.writeText("future-desktop") + assertNotNull(DesktopCatalog.removeDesktop(context, listener)) + assertEquals("future-desktop", marker.readText()) + marker.writeText(BuildConfig.DESKTOP_KDE_TAG) + journal.writeText(DesktopCatalog.entryJson(DesktopCatalog.desktopEntry(context)).put("version", "future-desktop").toString()) + assertNotNull(DesktopCatalog.removeDesktop(context, listener)) + assertTrue(journal.exists()) + journal.delete() + File(root, "var/lib/pacman/local/base-1/files").delete() + assertNotNull(DesktopCatalog.removeDesktop(context, listener)) + assertEquals(BuildConfig.DESKTOP_KDE_TAG, marker.readText()) + assertFalse(pending.exists()) + assertTrue(Files.isSymbolicLink(desktop.toPath())) + } + + @Test fun failedDownloadCleanupKeepsTheInstallRecordSoRemovalCanRetry() { + val entry = DesktopCatalog.desktopEntry(context) + val download = File(context.cacheDir, "pkg-${entry.id}-${entry.sha256.take(12)}.download") + for (blocked in listOf(download, File(download.path + ".resume.properties"))) { + desktopFiles() + journal.writeText(DesktopCatalog.entryJson(entry).toString()) + blocked.mkdirs() + val blocker = File(blocked, "blocker").apply { writeText("fixture") } + + assertNotNull(DesktopCatalog.removeDesktop(context, listener)) + assertTrue(journal.exists()) + assertTrue(pending.exists()) + assertTrue(blocker.delete()) + assertNull(DesktopCatalog.removeDesktop(context, listener)) + assertFalse(blocked.exists()) + assertFalse(journal.exists()) + assertFalse(pending.exists()) + } + } + + private fun file(path: String, text: String) = File(root, path).apply { parentFile!!.mkdirs(); writeText(text) } + + private fun desktopFiles(): File { + file("var/lib/pacman/local/base-1/files", "%FILES%\nusr/lib/shared.so\n") + val entry = GZIPInputStream(context.assets.open("desktop-removal/kde-remove.tsv.gzip")).bufferedReader().use { reader -> + reader.lineSequence().map(DesktopFileRemoval.Entry::parse).first { it.kind == "L" && it.path.startsWith("usr/") } + } + return File(root, entry.path).apply { + parentFile!!.mkdirs() + Files.createSymbolicLink(toPath(), Paths.get(entry.identity)) + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/session/ComponentsNightlyCatalogTest.kt b/app/src/test/java/com/droiddeck/launcher/session/ComponentsNightlyCatalogTest.kt new file mode 100644 index 0000000000..8fbb0bacd5 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/session/ComponentsNightlyCatalogTest.kt @@ -0,0 +1,73 @@ +package com.droiddeck.launcher.session + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +class ComponentsNightlyCatalogTest { + @Test + fun nightlyFilesGoToTheirComponentList() { + val n = ComponentsManager.DD_NIGHTLY + assertEquals("dxvk", ComponentsManager.assetComp(n, "DD-dxvk-3.1.1+153-nightly.wcp")) + assertEquals("dxvk", ComponentsManager.assetComp(n, "DD-dxvk-arm64ec-3.1.1+153-nightly.wcp")) + assertEquals("dxvk", ComponentsManager.assetComp(n, "DD-dxvk-gplasync-3.1.1+153-nightly.wcp")) + assertEquals("vkd3d", ComponentsManager.assetComp(n, "DD-vkd3d-proton-arm64ec-3.0.1+455-nightly.wcp")) + assertEquals("fex", ComponentsManager.assetComp(n, "DD-FEXCore-2610+58-nightly.wcp")) + assertNull(ComponentsManager.assetComp(n, "state.json")) + assertNull(ComponentsManager.assetComp(n, "something-else.wcp")) + assertEquals("dxvk", ComponentsManager.assetComp("Dxvk-gplasync-Linux", "dxvk-gplasync-3.1.1-1-linux.wcp")) + assertNull(ComponentsManager.assetComp("Unknown-Release", "dxvk-3.1.1-linux.wcp")) + } + + @Test + fun nightliesListBelowTheStablePackages() { + fun item(file: String, release: String) = ComponentsManager.CatalogItem(file, "dxvk", release, "", 0, "") + val sorted = listOf( + item("DD-dxvk-3.1.1+153-nightly.wcp", ComponentsManager.DD_NIGHTLY), + item("dxvk-2.7.1-linux.wcp", "Dxvk-Linux"), + item("dxvk-3.1.1-linux.wcp", "Dxvk-Linux"), + ).sortedWith(ComponentsManager.CATALOG_ORDER).map { it.file } + assertEquals(listOf("dxvk-3.1.1-linux.wcp", "dxvk-2.7.1-linux.wcp", "DD-dxvk-3.1.1+153-nightly.wcp"), sorted) + } + + @Test + fun nightliesPairWithTheStableOfTheSameFlavorAndVersion() { + val n = ComponentsManager.DD_NIGHTLY + fun item(file: String, comp: String, release: String) = ComponentsManager.CatalogItem(file, comp, release, "", 0, "") + val dxvk = item("dxvk-3.1.1-linux.wcp", "dxvk", "Dxvk-Linux") + val ec = item("dxvk-arm64ec-3.1.1-linux.wcp", "dxvk", "Dxvk-arm64ec-Linux") + val gpl = item("dxvk-gplasync-3.1.1-1-linux.wcp", "dxvk", "Dxvk-gplasync-Linux") + val fex = item("FEXCore-2610-linux.wcp", "fex", "FexCore-Linux") + val vk = item("vkd3d-proton-3.0.1-linux.wcp", "vkd3d", "Vkd3d-proton-Linux") + val others = listOf( + item("dxvk-low-latency-3.1.1-2-linux.wcp", "dxvk", "Dxvk-Linux"), + item("dxvk-3.1-linux.wcp", "dxvk", "Dxvk-Linux"), + item("dxvk-gplasync-3.1-1-linux.wcp", "dxvk", "Dxvk-gplasync-Linux"), + item("FEXCore-2610-d2rfix28-linux.wcp", "fex", "FexCore-Linux"), + ) + val nDxvk = item("DD-dxvk-3.1.1+153-nightly.wcp", "dxvk", n) + val nEc = item("DD-dxvk-arm64ec-3.1.1+153-nightly.wcp", "dxvk", n) + val nGpl = item("DD-dxvk-gplasync-3.1.1+153-nightly.wcp", "dxvk", n) + val nFex = item("DD-FEXCore-2610+58-nightly.wcp", "fex", n) + val nVk = item("DD-vkd3d-proton-3.0.1+455-nightly.wcp", "vkd3d", n) + val nVkEc = item("DD-vkd3d-proton-arm64ec-3.0.1+455-nightly.wcp", "vkd3d", n) + val pairs = ComponentsManager.nightlyPairs(listOf(dxvk, ec, gpl, fex, vk) + others + listOf(nDxvk, nEc, nGpl, nFex, nVk, nVkEc)) + assertEquals(mapOf(dxvk to nDxvk, ec to nEc, gpl to nGpl, fex to nFex, vk to nVk), pairs) + // Two nightlies for one stable build: the newer one wins. + val nDxvkNewer = item("DD-dxvk-3.1.1+154-nightly.wcp", "dxvk", n) + assertEquals(mapOf(dxvk to nDxvkNewer), ComponentsManager.nightlyPairs(listOf(dxvk, nDxvkNewer, nDxvk))) + assertEquals(mapOf(dxvk to nDxvkNewer), ComponentsManager.nightlyPairs(listOf(dxvk, nDxvk, nDxvkNewer))) + // A nightly of a version with no stable build pairs with nothing. + assertEquals(emptyMap(), ComponentsManager.nightlyPairs(listOf(item("dxvk-3.1-linux.wcp", "dxvk", "Dxvk-Linux"), nDxvk))) + } + + @Test + fun downloadsOnlyFromTheTwoRepositories() { + assertTrue(ComponentsManager.allowedDownload("https://github.com/The412Banner/Nightlies/releases/download/Dxvk-Linux/dxvk-3.1.1-linux.wcp")) + assertTrue(ComponentsManager.allowedDownload("https://github.com/Droid-Deck/DroidDeck-Components/releases/download/linux-nightly/DD-FEXCore-2610+58-nightly.wcp")) + assertFalse(ComponentsManager.allowedDownload("https://github.com/someone/else/releases/download/x/y.wcp")) + assertFalse(ComponentsManager.allowedDownload("https://github.com/Droid-Deck/DroidDeck-Components-evil/releases/download/x/y.wcp")) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/session/OrientationTest.kt b/app/src/test/java/com/droiddeck/launcher/session/OrientationTest.kt index 5d67d041a2..5ce8030d5a 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/OrientationTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/OrientationTest.kt @@ -20,7 +20,7 @@ class OrientationTest { } @Test fun landscapeChoicesPersistGloballyAndCanRestoreAutomaticRotation() { - assertEquals(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE, SessionPrefs.orientation(context)) + assertEquals(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE, SessionPrefs.orientation(context)) for (value in listOf( ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE, ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE, @@ -34,7 +34,7 @@ class OrientationTest { @Test fun invalidStoredOrientationFallsBackAndInvalidChoicePreservesTheSavedValue() { val prefs = context.getSharedPreferences("session", Context.MODE_PRIVATE) prefs.edit().putInt("orientation", ActivityInfo.SCREEN_ORIENTATION_PORTRAIT).commit() - assertEquals(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE, SessionPrefs.orientation(context)) + assertEquals(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE, SessionPrefs.orientation(context)) SessionPrefs.setOrientation(context, ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE) assertThrows(IllegalArgumentException::class.java) { SessionPrefs.setOrientation(context, ActivityInfo.SCREEN_ORIENTATION_PORTRAIT) diff --git a/app/src/test/java/com/droiddeck/launcher/session/SettingsResetTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SettingsResetTest.kt index 81ace45da4..3f3fbf07f8 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/SettingsResetTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/SettingsResetTest.kt @@ -32,6 +32,11 @@ class SettingsResetTest { SessionPrefs.setHdr(app, SessionService.MODE_DESKTOP, true) SessionPrefs.setResolutionChoice(app, SessionService.MODE_STEAM, "1280x800") SessionPrefs.setGuestHostname(app, "MyDeck") + SessionPrefs.setHudShowFps(app, false) + SessionPrefs.setHudShowBattery(app, false) + SessionPrefs.setHudShowGraph(app, false) + SessionPrefs.setHudColor(app, "amber") + SessionPrefs.setHudOpacity(app, 40) ControllerPrefs.setOpacity(app, 40) AppUiPrefs.setScale(app, 150) FrameGen.set(app, FrameGen.Mode(FrameGen.ENGINE_DDFG, 3)) @@ -45,6 +50,13 @@ class SettingsResetTest { assertFalse(SessionPrefs.hdr(app, SessionService.MODE_DESKTOP)) assertFalse(SessionPrefs.resolutionChosen(app, SessionService.MODE_STEAM)) assertEquals(SessionPrefs.DEFAULT_GUEST_HOSTNAME, SessionPrefs.guestHostname(app)) + assertTrue(SessionPrefs.hudShowFps(app)) + assertTrue(SessionPrefs.hudShowBattery(app)) + assertTrue(SessionPrefs.hudShowGraph(app)) + assertEquals(SessionPrefs.HUD_COLOR_MINT, SessionPrefs.hudColor(app)) + assertEquals(SessionPrefs.HUD_OPACITY_DEFAULT, SessionPrefs.hudOpacity(app)) + assertEquals("32.4°C", PerfHud.batteryCelsius(324)) + assertNull(PerfHud.batteryCelsius(0)) assertEquals(100, ControllerPrefs.read(app).opacity) assertEquals(AppUiPrefs.DEFAULT_SCALE, AppUiPrefs.scale(app)) assertEquals(FrameGen.Mode.OFF.engine, FrameGen.engine(app)) diff --git a/app/src/test/java/com/droiddeck/launcher/session/SteamDownloadMonitorTest.kt b/app/src/test/java/com/droiddeck/launcher/session/SteamDownloadMonitorTest.kt index c392107376..e60c6dcd9f 100644 --- a/app/src/test/java/com/droiddeck/launcher/session/SteamDownloadMonitorTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/session/SteamDownloadMonitorTest.kt @@ -57,6 +57,25 @@ class SteamDownloadMonitorTest { } } + @Test fun readsBoundCardLibrariesFromTheirHostPath() { + val root = Files.createTempDirectory("droiddeck-steam-download-").toFile() + try { + val card = File(root, "card").apply { mkdirs() } + File(root, "root/.local/share/Steam/steamapps").apply { mkdirs() } + .resolve("libraryfolders.vdf") + .writeText("\"libraryfolders\" { \"1\" { \"path\" \"/mnt/droiddeck-sd\" } }") + val manifest = manifest(card, "44", downloaded = 10, total = 100, flags = 6) + val monitor = SteamDownloadMonitor() + val mounts = mapOf("/mnt/droiddeck-sd" to card) + + assertFalse(monitor.poll(root, now = 1_000L, mounts = mounts)) + manifest.writeText(appManifest(downloaded = 20, total = 100, flags = 6)) + assertTrue(monitor.poll(root, now = 3_000L, mounts = mounts)) + } finally { + root.deleteRecursively() + } + } + @Test fun followsSteamContentActivityWhenManifestProgressIsNotFlushed() { val root = Files.createTempDirectory("droiddeck-steam-download-").toFile() try { diff --git a/app/src/test/java/com/droiddeck/launcher/stores/DetailCatalogItemTest.kt b/app/src/test/java/com/droiddeck/launcher/stores/DetailCatalogItemTest.kt new file mode 100644 index 0000000000..dc55121719 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/stores/DetailCatalogItemTest.kt @@ -0,0 +1,29 @@ +package com.droiddeck.launcher.stores + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test + +class DetailCatalogItemTest { + private fun item(store: Store, id: String, title: String) = CatalogItem(store, id, title, imageUrl = null) + private val shelves = StoreShelves(trending = listOf(item(Store.XBOX, "9SHELF000001", "Shelf game"))) + + @Test fun aSearchOnlyResultKeepsItsMetadataOnTheDetailPage() { + val found = listOf(item(Store.XBOX, "9SEARCH00001", "Echo Weaver")) + assertEquals("Echo Weaver", detailCatalogItem(Store.XBOX, "9SEARCH00001", emptyList(), found, shelves)?.title) + } + + @Test fun theLibraryWinsOverSearchAndShelvesForTheSameProduct() { + val library = listOf(item(Store.XBOX, "9SEARCH00001", "Echo Weaver").copy(owned = true, sizeBytes = 42)) + val found = listOf(item(Store.XBOX, "9SEARCH00001", "Echo Weaver").copy(owned = false)) + val resolved = detailCatalogItem(Store.XBOX, "9SEARCH00001", library, found, shelves)!! + assertEquals(true, resolved.owned) + assertEquals(42L, resolved.sizeBytes) + } + + @Test fun shelvesRemainAFallbackAndTheItemStaysInItsStore() { + assertEquals("Shelf game", detailCatalogItem(Store.XBOX, "9SHELF000001", emptyList(), emptyList(), shelves)?.title) + assertNull(detailCatalogItem(Store.GOG, "9SEARCH00001", emptyList(), listOf(item(Store.XBOX, "9SEARCH00001", "Echo Weaver")), shelves)) + assertNull(detailCatalogItem(Store.XBOX, "9UNKNOWN0001", emptyList(), emptyList(), shelves)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/stores/StoreCatalogPatchTest.kt b/app/src/test/java/com/droiddeck/launcher/stores/StoreCatalogPatchTest.kt new file mode 100644 index 0000000000..e545cc77d1 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/stores/StoreCatalogPatchTest.kt @@ -0,0 +1,29 @@ +package com.droiddeck.launcher.stores + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertSame +import org.junit.Test + +/** Filling a grid one card at a time: what is on screen stays put, what is new lands where its title belongs. */ +class StoreCatalogPatchTest { + private fun item(id: String, title: String, image: String? = null) = CatalogItem(Store.GOG, id, title, imageUrl = image, owned = true) + + @Test fun onlyTheCardItWasGivenIsReplaced() { + val alpha = item("1", "Alpha") + val beta = item("2", "Beta") + val next = patchItems(listOf(alpha, beta), listOf(item("2", "Beta", "wide.jpg"))) + assertEquals(2, next.size) + assertSame(alpha, next[0]) + assertEquals("wide.jpg", next[1].imageUrl) + } + + @Test fun aCardTheGridDoesNotHaveYetIsAddedInTitleOrder() { + val next = patchItems(listOf(item("1", "Alpha"), item("3", "Gamma")), listOf(item("2", "Beta"))) + assertEquals(listOf("Alpha", "Beta", "Gamma"), next.map { it.title }) + } + + @Test fun anEmptyGridTakesTheCardAsItComes() { + val next = patchItems(null, listOf(item("2", "Beta"))) + assertEquals(listOf("Beta"), next.map { it.title }) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/stores/StoreLanguageTest.kt b/app/src/test/java/com/droiddeck/launcher/stores/StoreLanguageTest.kt new file mode 100644 index 0000000000..c97ac2a3aa --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/stores/StoreLanguageTest.kt @@ -0,0 +1,93 @@ +package com.droiddeck.launcher.stores + +import org.json.JSONArray +import org.json.JSONObject +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config +import java.util.Locale + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [33], application = android.app.Application::class) +class StoreLanguageTest { + @Test + fun polishDepotIsKeptWhenPolishIsChosen() { + assertTrue(StoreLanguage.depotAccepted(arrayOf("pl-PL"), "pl")) + assertTrue(StoreLanguage.depotAccepted(arrayOf("pl"), "pl-PL")) + assertTrue(StoreLanguage.depotAccepted(arrayOf("polish"), "pl-PL")) + assertTrue(StoreLanguage.depotAccepted(arrayOf("*"), "pl")) + assertTrue(StoreLanguage.depotAccepted(emptyArray(), "pl")) + assertTrue(StoreLanguage.depotAccepted(null, "pl")) + } + + @Test + fun englishDepotIsSkippedWhenPolishIsChosen() { + assertFalse(StoreLanguage.depotAccepted(arrayOf("en-US"), "pl-PL")) + assertFalse(StoreLanguage.depotAccepted(arrayOf("en", "english"), "pl")) + assertTrue(StoreLanguage.depotAccepted(arrayOf("en-US"), "en")) + assertTrue(StoreLanguage.depotAccepted(arrayOf("en"), "en-US")) + assertTrue(StoreLanguage.depotAccepted(arrayOf("english"), "en-US")) + } + + @Test + fun pickPrefersSystemLanguageThenEnglish() { + val available = listOf("en-US", "de-DE", "pl-PL") + assertEquals("pl-PL", StoreLanguage.pick(available, "pl")) + assertEquals("en-US", StoreLanguage.pick(available, "ja")) + assertEquals("de-DE", StoreLanguage.pick(listOf("de-DE", "fr-FR"), "de")) + assertEquals("wanted", StoreLanguage.pick(emptyList(), "wanted")) + } + + @Test + fun pickPrefersExactCodeBeforeTheBaseLanguage() { + val both = listOf("pl", "pl-PL", "en-US") + assertEquals("pl-PL", StoreLanguage.pick(both, "pl-PL")) + assertEquals("pl", StoreLanguage.pick(both, "pl")) + assertEquals("pl-PL", StoreLanguage.pick(listOf("en-US", "pl-PL"), "pl")) + } + + @Test + fun resolvedDepotKeepsSharedFilesAndOnlyTheChosenVariant() { + assertTrue(StoreLanguage.depotMatchesResolved(arrayOf("*"), "pl-PL")) + assertTrue(StoreLanguage.depotMatchesResolved(emptyArray(), "pl-PL")) + assertTrue(StoreLanguage.depotMatchesResolved(null, "pl-PL")) + assertTrue(StoreLanguage.depotMatchesResolved(arrayOf("pl-PL", "*"), "pl-PL")) + assertTrue(StoreLanguage.depotMatchesResolved(arrayOf("pl-PL"), "pl-PL")) + assertFalse(StoreLanguage.depotMatchesResolved(arrayOf("pl"), "pl-PL")) + assertFalse(StoreLanguage.depotMatchesResolved(arrayOf("en-US"), "pl-PL")) + assertTrue(StoreLanguage.depotMatchesResolved(arrayOf("polish"), "pl")) + } + + @Test + fun tagForFollowsLocale() { + assertEquals("pl-PL", StoreLanguage.tagFor(Locale("pl", "PL"))) + assertEquals("pl", StoreLanguage.tagFor(Locale("pl"))) + assertEquals("pt-BR", StoreLanguage.tagFor(Locale("pt", "BR"))) + assertEquals("es-419", StoreLanguage.tagFor(Locale("es", "MX"))) + assertEquals("zh-Hans", StoreLanguage.tagFor(Locale.SIMPLIFIED_CHINESE)) + assertEquals("zh-Hant", StoreLanguage.tagFor(Locale.TRADITIONAL_CHINESE)) + } + + @Test + fun codesFromDepotsSkipStarAndDuplicates() { + val depots = JSONArray() + .put(JSONObject().put("languages", JSONArray().put("*").put("en-US"))) + .put(JSONObject().put("languages", JSONArray().put("pl-PL").put("en-US"))) + .put(JSONObject().put("languages", JSONArray())) + assertEquals(listOf("en-US", "pl-PL"), StoreLanguage.codesFromDepots(depots)) + assertTrue(StoreLanguage.codesFromDepots(null).isEmpty()) + } + + @Test + fun selectableStoresAreGogAndEpic() { + assertTrue(StoreLanguage.selectable(Store.GOG)) + assertTrue(StoreLanguage.selectable(Store.EPIC)) + assertFalse(StoreLanguage.selectable(Store.AMAZON)) + assertFalse(StoreLanguage.selectable(Store.XBOX)) + assertFalse(StoreLanguage.selectable(Store.ITCH)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/stores/gog/GogListingTest.kt b/app/src/test/java/com/droiddeck/launcher/stores/gog/GogListingTest.kt new file mode 100644 index 0000000000..0c6502e939 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/stores/gog/GogListingTest.kt @@ -0,0 +1,79 @@ +package com.droiddeck.launcher.stores.gog + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +/** The account listing: everything the tab needs to draw a library before a product is asked about. */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [33]) +class GogListingTest { + @Test + fun aPageCarriesTheGamesTheAppCanInstall() { + val page = GogLibrary.parseListing(PAGE)!! + assertEquals(2, page.totalPages) + assertEquals(listOf("Shadowrun Returns", "Witcher 3: Wild Hunt, The"), page.games.map { it.title }) + val shadowrun = page.games[0] + assertEquals("1207660413", shadowrun.gameId) + assertEquals("https://images-2.gog.com/6c35ecb988f57725cc0f385acf860241082da16eda9fab66115f4da883dae3d1_glx_vertical_cover.webp", shadowrun.verticalCover) + assertEquals("", shadowrun.imageUrl) + assertEquals("Role-playing", shadowrun.category) + assertEquals("2013-07-25", shadowrun.releaseDate) + assertEquals("", shadowrun.description) + } + + @Test + fun moviesOtherPlatformsAndGalaxysOwnEntryAreLeftOut() { + assertEquals(listOf("1207660413", "1207664663"), GogLibrary.parseListing(PAGE)!!.games.map { it.gameId }) + } + + @Test + fun aResponseThatIsNotAListingIsNull() { + assertNull(GogLibrary.parseListing("""{"error":"unauthorized"}""")) + assertNull(GogLibrary.parseListing("not json")) + } + + private companion object { + val PAGE = """ + { + "sortBy": "title", + "page": 1, + "totalProducts": 6, + "totalPages": 2, + "productsPerPage": 100, + "products": [ + { + "id": 1207660413, + "title": "Shadowrun Returns", + "image": "//images-2.gog.com/6c35ecb988f57725cc0f385acf860241082da16eda9fab66115f4da883dae3d1", + "worksOn": { "Windows": true, "Mac": true, "Linux": true }, + "category": "Role-playing", + "isComingSoon": false, + "isMovie": false, + "isGame": true, + "slug": "shadowrun_returns", + "dlcCount": 0, + "releaseDate": { "date": "2013-07-25 00:00:00.000000", "timezone_type": 3, "timezone": "Europe/Nicosia" } + }, + { + "id": 1207664663, + "title": " Witcher 3: Wild Hunt, The ", + "image": "//images-3.gog.com/60c724a052275a049d857d53957dc38e9347742f52372bb956d992b43efa8fb5", + "worksOn": { "Windows": true, "Mac": false, "Linux": false }, + "category": "Role-playing", + "isMovie": false, + "isGame": true, + "releaseDate": { "date": "2015-05-19 02:00:00.000000", "timezone_type": 3, "timezone": "Europe/Nicosia" } + }, + { "id": 1582718039, "title": "A Movie", "image": "//images-1.gog.com/movie", "isMovie": true, "isGame": false }, + { "id": 1430747193, "title": "Mac Only", "image": "//images-1.gog.com/mac", "worksOn": { "Windows": false, "Mac": true }, "isMovie": false, "isGame": true }, + { "id": 1801418160, "title": "GOG Galaxy", "image": "//images-1.gog.com/galaxy", "worksOn": { "Windows": true }, "isMovie": false, "isGame": true }, + { "id": 1401362385, "title": "Soundtrack", "image": "//images-1.gog.com/ost", "worksOn": { "Windows": true }, "isMovie": false, "isGame": false } + ] + } + """.trimIndent() + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/stores/xbox/XboxCatalogTest.kt b/app/src/test/java/com/droiddeck/launcher/stores/xbox/XboxCatalogTest.kt index c5e6927e7a..c4f95c0918 100644 --- a/app/src/test/java/com/droiddeck/launcher/stores/xbox/XboxCatalogTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/stores/xbox/XboxCatalogTest.kt @@ -19,7 +19,7 @@ class XboxCatalogTest { private fun envelope(vararg rows: JSONObject) = JSONObject().put("schema", 1).put("account", "test@example.test") .put("market", "US").put("checkedAt", now.toString()).put("entitlements", JSONArray(rows.toList())) private fun access(vararg rows: JSONObject) = XboxCatalog.access(envelope(*rows), "test@example.test", "US", now) - private fun membership() = JSONObject().put("productId", plan).put("status", "Active").put("endDate", "2099-01-01T00:00:00Z") + private fun membership(id: String = plan) = JSONObject().put("productId", id).put("status", "Active").put("endDate", "2099-01-01T00:00:00Z") private fun withMembership(json: JSONObject, vararg plans: JSONObject) = json.put("subscriptions", JSONArray(plans.toList())) @Test fun separateMembershipRestoresSubscriptionChildrenWithoutInventingOwnership() { @@ -83,6 +83,16 @@ class XboxCatalogTest { assertEquals(mapOf(game to "gamepass", parent to "gamepass"), access(row(game, parent), row(parent, plan), row(plan))) } + @Test fun onlyPcPlansGrantSubscriptionAccess() { + for (pc in listOf("CFQ7TTC0KGQ8", "CFQ7TTC0KHS0", "CFQ7TTC0P85B", "CFQ7TTC0K5DJ", "CFQ7TTC10QFD")) { + assertEquals(mapOf(game to "gamepass"), access(row(game, pc), row(pc))) + } + val console = "CFQ7TTC0K6L8" + assertTrue(access(row(game, console), row(console)).isEmpty()) + assertTrue(XboxCatalog.access(withMembership(envelope(row(game, console)), membership(console)), + "test@example.test", "US", now).isEmpty()) + } + @Test fun backendRfc3339OffsetsAndNanosecondsAreAccepted() { val checked = "2026-10-19T19:02:38.173609086+00:00" val response = envelope(row(game).put("endDate", "2099-01-01T01:00:00.000000001+01:00")) @@ -120,6 +130,29 @@ class XboxCatalogTest { assertFalse(card.owned); assertTrue(card.subscription) } + @Test fun pcSubscriptionAffirmationsOfferAnInstallWithoutClaimingOwnership() { + fun offer(vararg affirmations: String) = JSONObject().put("ProductId", game).put("ProductType", "Game") + .put("LocalizedProperties", JSONArray().put(JSONObject().put("ProductTitle", "A Pass game") + .put("EligibilityProperties", JSONObject().put("Affirmations", JSONArray(affirmations.map { + JSONObject().put("AffirmationProductId", it) + }))))) + .put("DisplaySkuAvailabilities", JSONArray().put(JSONObject().put("Sku", JSONObject().put("Properties", JSONObject() + .put("Packages", JSONArray().put(JSONObject().put("PackageFormat", "MSIXVC").put("PlatformDependencies", + JSONArray().put(JSONObject().put("PlatformName", "Windows.Desktop"))))))))) + + val pc = XboxCatalog.product(offer("CFQ7TTC0KGQ8"), emptyMap())!! + assertEquals("PC Game Pass", pc.includedWith) + assertFalse(pc.accessible); assertTrue(pc.installable) + + assertEquals("Game Pass Ultimate", XboxCatalog.product(offer("CFQ7TTC0KHS0"), emptyMap())!!.includedWith) + assertEquals("Xbox Game Pass Premium", XboxCatalog.product(offer("CFQ7TTC0P85B"), emptyMap())!!.includedWith) + assertEquals("Xbox Game Pass Essential", XboxCatalog.product(offer("CFQ7TTC0K5DJ"), emptyMap())!!.includedWith) + assertEquals("Xbox Game Pass (Starter Edition)", XboxCatalog.product(offer("CFQ7TTC10QFD"), emptyMap())!!.includedWith) + val console = XboxCatalog.product(offer("CFQ7TTC0K6L8"), emptyMap())!! + assertEquals("", console.includedWith); assertFalse(console.installable) + assertFalse(XboxCatalog.product(offer(), emptyMap())!!.installable) + } + @Test fun consoleAndUwpOffersAreFilteredOut() { fun product(platform: String, format: String) = JSONObject().put("ProductId", game).put("ProductType", "Game") .put("LocalizedProperties", JSONArray().put(JSONObject().put("ProductTitle", "A PC game"))) diff --git a/app/src/test/java/com/droiddeck/launcher/ui/CloudMessageTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/CloudMessageTest.kt new file mode 100644 index 0000000000..2bf7360edf --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/ui/CloudMessageTest.kt @@ -0,0 +1,33 @@ +package com.droiddeck.launcher.ui + +import com.droiddeck.launcher.R +import com.droiddeck.launcher.stores.CloudSaves +import org.junit.Assert.assertEquals +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [33]) +class CloudMessageTest { + private val ctx get() = RuntimeEnvironment.getApplication() + private fun msg(result: String, files: Int, conflicts: Int, reason: String) = + cloudMessage(ctx, CloudSaves.Result(result, files, 0L, reason, conflicts)) + + @Test fun aSkippedSyncNeverReadsAsZeroFilesDone() { + assertEquals(ctx.getString(R.string.cloud_signed_out), msg("skipped", 0, 0, "not-signed-in")) + assertEquals(ctx.getString(R.string.cloud_none), msg("skipped", 0, 0, "no-cloud-saves")) + for (reason in listOf("off", "no-baseline", "nothing-local", "store-unreachable", "unresolved")) { + assertEquals(reason, ctx.getString(R.string.cloud_not_synced), msg("skipped", 0, 0, reason)) + } + assertEquals(ctx.getString(R.string.cloud_not_synced), msg("failed", 0, 0, "SocketTimeoutException")) + } + + @Test fun okResultsSayWhatHappened() { + assertEquals(ctx.getString(R.string.cloud_up_to_date), msg("ok", 0, 0, "up-to-date")) + assertEquals(ctx.getString(R.string.cloud_done, 3), msg("ok", 3, 0, "uploaded")) + assertEquals(ctx.getString(R.string.cloud_conflict_files, 2), msg("ok", 1, 2, "conflict")) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/ui/ComponentDownloadsDrawerTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/ComponentDownloadsDrawerTest.kt index 8da1e7fa3b..4d3f1852a5 100644 --- a/app/src/test/java/com/droiddeck/launcher/ui/ComponentDownloadsDrawerTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/ui/ComponentDownloadsDrawerTest.kt @@ -4,11 +4,20 @@ import androidx.compose.foundation.layout.Column import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.verticalScroll import androidx.compose.ui.Modifier +import androidx.compose.ui.input.InputMode +import androidx.compose.ui.input.InputModeManager +import androidx.compose.ui.input.key.Key +import androidx.compose.ui.platform.LocalInputModeManager import androidx.compose.ui.platform.testTag +import androidx.compose.ui.test.assertIsFocused +import androidx.compose.ui.test.ExperimentalTestApi import androidx.compose.ui.test.assertIsNotEnabled import androidx.compose.ui.test.onNodeWithTag import androidx.compose.ui.test.onNodeWithText import androidx.compose.ui.test.performClick +import androidx.compose.ui.test.performKeyInput +import androidx.compose.ui.test.pressKey +import androidx.compose.ui.test.requestFocus import com.droiddeck.launcher.R import com.droiddeck.launcher.session.ComponentsManager import org.junit.Assert.assertEquals @@ -19,10 +28,12 @@ import org.robolectric.RobolectricTestRunner import org.robolectric.RuntimeEnvironment import org.robolectric.annotation.Config +@OptIn(ExperimentalTestApi::class, androidx.compose.ui.ExperimentalComposeUiApi::class) @RunWith(RobolectricTestRunner::class) @Config(sdk = [28]) class ComponentDownloadsDrawerTest { @get:Rule val compose = createRobolectricComposeRule() + private lateinit var inputMode: InputModeManager private val dxvk = item("dxvk-2.4.1-linux.wcp", "dxvk") private val stored = item("dxvk-2.3-linux.wcp", "dxvk") @@ -42,6 +53,40 @@ class ComponentDownloadsDrawerTest { compose.onNodeWithText("45%").assertExists() } + @Test fun pairedNightlyRidesOnTheStableRowBehindTheSwitch() { + val stable = ComponentsManager.CatalogItem("dxvk-3.1.1-linux.wcp", "dxvk", "Dxvk-Linux", "https://github.com/example/s", 100, "sha256:test") + val nightly = ComponentsManager.CatalogItem("DD-dxvk-3.1.1+153-nightly.wcp", "dxvk", ComponentsManager.DD_NIGHTLY, "https://github.com/example/n", 100, "sha256:test") + val requested = mutableListOf() + show(catalog = listOf(stable, nightly), onDownload = requested::add) + compose.onNodeWithTag("cmp-download-dxvk").performClick() + compose.onNodeWithText("dxvk-3.1.1-linux").assertExists() + compose.onNodeWithText("DD-dxvk-3.1.1+153-nightly").assertDoesNotExist() + compose.onNodeWithText(RuntimeEnvironment.getApplication().getString(R.string.comp_channel_nightly)).performClick() + compose.onNodeWithText("dxvk-3.1.1-linux").assertDoesNotExist() + compose.onNodeWithText("DD-dxvk-3.1.1+153-nightly").performClick() + assertEquals(listOf(nightly), requested) + } + + @Test fun controllerPicksNightlyOnItsTabThenDownloadsItFromTheRow() { + val stable = ComponentsManager.CatalogItem("dxvk-3.1.1-linux.wcp", "dxvk", "Dxvk-Linux", "https://github.com/example/s", 100, "sha256:test") + val nightly = ComponentsManager.CatalogItem("DD-dxvk-3.1.1+153-nightly.wcp", "dxvk", ComponentsManager.DD_NIGHTLY, "https://github.com/example/n", 100, "sha256:test") + val requested = mutableListOf() + show(catalog = listOf(stable, nightly), onDownload = requested::add) + compose.onNodeWithTag("cmp-download-dxvk").performClick() + compose.runOnIdle { inputMode.requestInputMode(InputMode.Keyboard) } + compose.onNodeWithText("dxvk-3.1.1-linux").requestFocus().assertIsFocused() + compose.onNodeWithText("dxvk-3.1.1-linux").performKeyInput { pressKey(Key.DirectionRight) } + val nightlyTab = RuntimeEnvironment.getApplication().getString(R.string.comp_channel_nightly) + compose.onNodeWithText(RuntimeEnvironment.getApplication().getString(R.string.comp_channel_stable)).assertIsFocused() + .performKeyInput { pressKey(Key.DirectionRight) } + compose.onNodeWithText(nightlyTab).assertIsFocused().performKeyInput { pressKey(Key.ButtonA) } + compose.onNodeWithText("DD-dxvk-3.1.1+153-nightly").assertExists() + assertEquals(emptyList(), requested) + compose.onNodeWithText(nightlyTab).performKeyInput { pressKey(Key.DirectionLeft); pressKey(Key.DirectionLeft) } + compose.onNodeWithText("DD-dxvk-3.1.1+153-nightly").assertIsFocused().performKeyInput { pressKey(Key.ButtonA) } + assertEquals(listOf(nightly), requested) + } + @Test fun emptyCatalogOffersRefreshAndDisablesVersionChoicesWhileChecking() { var refreshes = 0 show(catalog = emptyList(), checking = false, onRefresh = { refreshes++ }) @@ -64,6 +109,7 @@ class ComponentDownloadsDrawerTest { onDownload: (ComponentsManager.CatalogItem) -> Unit = {}, ) { compose.setContent { + inputMode = LocalInputModeManager.current DroidDeckTheme { Column(Modifier.verticalScroll(rememberScrollState())) { ComponentDownloadsDrawerGroup( diff --git a/app/src/test/java/com/droiddeck/launcher/ui/DesktopUninstallTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/DesktopUninstallTest.kt new file mode 100644 index 0000000000..3f76cac3ba --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/ui/DesktopUninstallTest.kt @@ -0,0 +1,101 @@ +package com.droiddeck.launcher.ui + +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.test.assertIsDisplayed +import androidx.compose.ui.test.assertIsNotEnabled +import androidx.compose.ui.test.onAllNodesWithText +import androidx.compose.ui.test.onLast +import androidx.compose.ui.test.onNodeWithText +import androidx.compose.ui.test.performClick +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34], qualifiers = "w1200dp-h752dp-land", application = android.app.Application::class) +class DesktopUninstallTest { + @get:Rule val compose = createRobolectricComposeRule() + private var removals = 0 + private var runtimeBlocked by mutableStateOf(false) + + @After fun closeConfirmation() { Steps.drop() } + + @Test fun uninstallIsAvailableOnTheDesktopPageAndRequiresConfirmation() { + show() + compose.onNodeWithText("Open desktop").assertIsDisplayed() + compose.onNodeWithText("Uninstall").assertIsDisplayed().performClick() + settle() + assertEquals(0, removals) + compose.onNodeWithText("Uninstall the desktop?").assertIsDisplayed() + compose.onAllNodesWithText("Uninstall").onLast().performClick() + assertEquals(1, removals) + } + + @Test fun uninstallIsDisabledWhileRuntimeChangesAreBlocked() { + show(blocked = true) + compose.onNodeWithText("Uninstall").assertIsNotEnabled() + } + + @Test fun aPartialDesktopStillOffersUninstall() { + show(installed = false) + compose.onNodeWithText("Uninstall").assertIsDisplayed() + } + + @Test fun anUninstalledDesktopNoLongerOffersUninstall() { + show(installed = false, present = false) + compose.onNodeWithText("Uninstall").assertDoesNotExist() + } + + @Test fun startingRuntimeWorkWhileConfirmingDisablesUninstall() { + show() + compose.onNodeWithText("Uninstall").performClick() + settle() + compose.runOnIdle { runtimeBlocked = true } + settle() + compose.onAllNodesWithText("Uninstall").onLast().assertIsNotEnabled() + assertEquals(0, removals) + } + + private fun settle() = compose.mainClock.advanceTimeBy(2_000) + + private fun show(installed: Boolean = true, blocked: Boolean = false, present: Boolean = true) { + runtimeBlocked = blocked + compose.mainClock.autoAdvance = false + compose.setContent { + DroidDeckTheme { + CompositionLocalProvider(LocalFrontFocus provides FrontFocus()) { + FocusGlideHost { + Box(Modifier.fillMaxSize()) { + DesktopPage(FrontEndState( + installed = "r9", ready = true, available = null, busy = false, stage = "", percent = -1, + desktopInstalled = installed, desktopPresent = present, runtimeActionsBlocked = runtimeBlocked, + offlineAccount = null, offline = false, frameGenLabel = "", romsDir = null, logsEnabled = false, + steamGames = emptyList(), emulators = emptyList(), running = null, + ), FrontEndActions( + onPlay = {}, onPlayDesktopUi = {}, onSteamGame = {}, onDesktop = {}, onEmulator = {}, onRom = {}, onResume = {}, + onSteamSettings = {}, onDesktopSettings = {}, onInstallPackage = {}, onRemovePackage = {}, + onRuntime = {}, onFrameGenPick = {}, onImportLossless = {}, onProtons = {}, onComponents = {}, + onPerformance = {}, onRoms = {}, onFiles = {}, onLogs = {}, onOffline = {}, + onWirelessAdbPair = { _, _, _, _ -> }, onWirelessAdbApply = { _, _, _, _ -> }, + onSetPhantomProcessLimit = { _, _ -> }, onRemoveDesktop = { removals++ }, + ), Modifier.fillMaxSize(), onSelect = {}) + StepsLayer(Offset.Zero) + } + } + } + } + } + settle() + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/ui/DialogSemanticsTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/DialogSemanticsTest.kt new file mode 100644 index 0000000000..c08c0f2341 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/ui/DialogSemanticsTest.kt @@ -0,0 +1,42 @@ +package com.droiddeck.launcher.ui + +import androidx.compose.animation.core.MutableTransitionState +import androidx.compose.material3.Text +import androidx.compose.runtime.remember +import androidx.compose.ui.test.assertHasNoClickAction +import androidx.compose.ui.test.onNodeWithText +import androidx.compose.ui.test.performClick +import org.junit.Assert.assertEquals +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28]) +class DialogSemanticsTest { + @get:Rule val compose = createRobolectricComposeRule() + + @Test fun dialogTextNodesStaySeparateAndNonClickableInMergedSemanticsTree() { + var closed = 0 + compose.setContent { + DroidDeckTheme { + val shown = remember { MutableTransitionState(true) } + AppDialog(shown = shown, close = { closed++ }, label = "testDialog", wide = false) { + Text("Dialog Title") + Text("Dialog Hint") + Text("Body Copy") + } + } + } + compose.onNodeWithText("Dialog Title").assertExists().assertHasNoClickAction() + compose.onNodeWithText("Dialog Hint").assertExists().assertHasNoClickAction() + compose.onNodeWithText("Body Copy").assertExists().assertHasNoClickAction() + + compose.onNodeWithText("Dialog Title").performClick() + compose.onNodeWithText("Body Copy").performClick() + compose.waitForIdle() + assertEquals(0, closed) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/ui/GestureLocalizationTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/GestureLocalizationTest.kt index e70caf7ddf..02d34e8083 100644 --- a/app/src/test/java/com/droiddeck/launcher/ui/GestureLocalizationTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/ui/GestureLocalizationTest.kt @@ -70,7 +70,6 @@ class GestureLocalizationTest { fun arabicPickerSearchPreservesBindingsAndMirrorsFooter() { assertEquals(View.LAYOUT_DIRECTION_RTL, context.resources.configuration.layoutDirection) compose.setContent { DroidDeckTheme { TouchGestureDialog(null, {}, {}) } } - compose.onNodeWithText("إعدادات إيماءات اللمس").assertIsDisplayed() val save = compose.onNodeWithTag("gesture-save").fetchSemanticsNode().boundsInRoot val cancel = compose.onNodeWithText(context.getString(R.string.gesture_cancel)).fetchSemanticsNode().boundsInRoot assertTrue("Save $save and Cancel $cancel should follow the right-to-left layout", save.left < cancel.left) diff --git a/app/src/test/java/com/droiddeck/launcher/ui/SecondScreenActivityTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/SecondScreenActivityTest.kt deleted file mode 100644 index 040ed3ff3e..0000000000 --- a/app/src/test/java/com/droiddeck/launcher/ui/SecondScreenActivityTest.kt +++ /dev/null @@ -1,61 +0,0 @@ -package com.droiddeck.launcher.ui - -import android.app.Application -import android.content.Intent -import android.hardware.display.DisplayManager -import android.view.Display -import com.droiddeck.launcher.SessionActivity -import com.droiddeck.launcher.session.SessionService -import com.droiddeck.launcher.session.SessionState -import org.junit.After -import org.junit.Assert.assertFalse -import org.junit.Assert.assertTrue -import org.junit.Before -import org.junit.Test -import org.junit.runner.RunWith -import org.robolectric.Robolectric -import org.robolectric.RobolectricTestRunner -import org.robolectric.Shadows.shadowOf -import org.robolectric.annotation.Config -import org.robolectric.annotation.LooperMode - -@RunWith(RobolectricTestRunner::class) -@Config(application = Application::class, manifest = Config.NONE, sdk = [28, 33]) -@LooperMode(LooperMode.Mode.PAUSED) -class SecondScreenActivityTest { - @Before fun setUp() { - SessionState.running = true - SessionState.stopRequested = false - } - - @After fun tearDown() { - SessionState.running = false - SessionState.stopRequested = false - } - - @Test fun removingControlsTaskDoesNotStopTheRunningSession() { - val service = Robolectric.buildService(SessionService::class.java).get() - service.onTaskRemoved(Intent(service, SecondScreenActivity::class.java)) - assertTrue(SessionState.running) - assertFalse(SessionState.stopRequested) - } - - @Test fun activityRestoredWithoutItsSessionOwnerFinishes() { - val activity = Robolectric.buildActivity(SecondScreenActivity::class.java).create().get() - assertTrue(activity.isFinishing) - assertTrue(SessionState.running) - } - - @Test fun closingBeforeTheSecondaryActivityStartsRejectsTheLateLaunch() { - val session = Robolectric.buildActivity(SessionActivity::class.java).get() - val display = session.getSystemService(DisplayManager::class.java).getDisplay(Display.DEFAULT_DISPLAY) - val controls = SecondScreenWindow(session, display, { _, _, _, _ -> }, { _, _ -> }, {}, {}, {}, {}) - controls.show() - val intent = shadowOf(session).nextStartedActivity - controls.closeControls() - val activity = Robolectric.buildActivity(SecondScreenActivity::class.java, intent).create().get() - assertTrue(activity.isFinishing) - assertFalse(controls.isShowing) - assertTrue(SessionState.running) - } -} diff --git a/app/src/test/java/com/droiddeck/launcher/update/SelfInstallerSignerTest.kt b/app/src/test/java/com/droiddeck/launcher/update/SelfInstallerSignerTest.kt new file mode 100644 index 0000000000..15c09f8b30 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/update/SelfInstallerSignerTest.kt @@ -0,0 +1,35 @@ +package com.droiddeck.launcher.update + +import android.content.pm.PackageInfo +import android.content.pm.Signature +import java.security.MessageDigest +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +class SelfInstallerSignerTest { + private val cert = byteArrayOf(1, 2, 3, 4, 5) + private val expected = MessageDigest.getInstance("SHA-256").digest(cert).joinToString("") { "%02x".format(it) } + + @Suppress("DEPRECATION") + private fun archive() = PackageInfo().apply { signatures = arrayOf(Signature(cert)) } + + @Config(sdk = [28, 29]) + @Test fun androidNineAndTenUseTheSignaturesWhenSigningInfoIsMissing() { + assertEquals(listOf(expected), SelfInstaller.archiveSignerDigests(archive())) + } + + @Config(sdk = [26]) + @Test fun androidEightIsCheckedToo() { + assertEquals(listOf(expected), SelfInstaller.archiveSignerDigests(archive())) + } + + @Config(sdk = [33]) + @Test fun anArchiveWithNoCertificatesHasNoDigests() { + assertTrue(SelfInstaller.archiveSignerDigests(PackageInfo()).isEmpty()) + } +} diff --git a/docs/cardboard-vr.md b/docs/cardboard-vr.md index 9f53acf980..8fd74154db 100644 --- a/docs/cardboard-vr.md +++ b/docs/cardboard-vr.md @@ -465,20 +465,31 @@ results, app recovery behavior, and the unverified powered-adapter design. ### Not done yet -- **Controllers**: the driver adds two Vive-profile hands driven by the session's game pad. It reads +- **Controllers**: the driver adds two hands driven by the session's game pad. It reads the absolute-state snapshot the app already publishes in fake input ring 0 - (`FAKE_EVDEV_MEMFD_PATHS`), so the app needs no new plumbing. They rest low in front of each side and - point where the head looks. Each stick moves its hand sideways (40 cm), up (50 cm) and down (30 cm) - and turns it as if from an elbow 45 cm behind, so pointers and aim follow it too; the hand eases - back when the stick is let go. The d-pad's up and down move both hands in and out; while a hand's - trigger or grip is held they move only that hand (a slingshot or bow pulled back), and it eases back - on release. Clicking the left stick hands the sticks to the game as trackpads (walking, turning, - teleport) and back. Mapping, right hand: A/R3 = trackpad click, RT = trigger, RB = grip, Start = menu, guide = - system. Left hand: X, LT, LB, Select. Both hands activate in SteamVR and their laser shows on the - dashboard; guide, Start and A presses show up in the ring the driver reads. They are drawn as Index - controllers and switch off while another driver's controller is connected. A Joy-Con hand replaces - the pad hand on its side, and bare camera hands replace both while no controller is connected - (above). + (`FAKE_EVDEV_MEMFD_PATHS`), so the app needs no new plumbing. **Play SteamVR → Settings → Controllers** + chooses what they are; the app writes the choice to `/run/droiddeck/droiddeck-vr-controllers` + (`emulate=index|touch|vive|off`, `sticks=game|hands`). The same choice is in the session menu's glasses page + and on the phone while the picture is on the glasses. The driver checks the file every second and switches + while SteamVR runs: SteamVR fixes a device's input profile when it activates, so each type gets its own pair + of devices, added the first time it is chosen, and the pair it replaces is disconnected: + - **Valve Index** (default) and **Meta Quest 3** (Touch Plus) are thumbstick controllers with the + stock input profiles, so games use their own Index or Touch bindings. Triggers are triggers, bumpers + grip, A/B and X/Y are each hand's face buttons, stick clicks are thumbstick clicks and Guide is system. + Quest's left menu button is Start or Select. + - **HTC Vive wands** keep the older layout: the sticks are trackpads, A/X or a stick click presses them, + Start and Select are menu. + - **Regular game pad** adds no hands, for games that play with a game pad. + + The hands rest low in front of each side and point where the head looks. By default the sticks move you + in the game; pressing both sticks in together switches them to moving the hands and back. Each stick then + moves its hand sideways (40 cm), up (50 cm) and down (30 cm) and turns it as if from an elbow 45 cm + behind, so pointers and aim follow it too; the hand eases back when the stick is let go. The d-pad's up + and down move both hands in and out; while a hand's trigger or grip is held they move only that hand + (a slingshot or bow pulled back), and it eases back on release. Both hands activate in SteamVR and their + laser shows on the dashboard. They switch off while another driver's controller is connected. A Joy-Con + hand replaces the pad hand on its side, and bare camera hands replace both while no controller is + connected (above). - **Layers**: only the first layer of each frame is drawn. SteamVR's compositor composites the dashboard into it, so this has not mattered yet. - **Timing**: no reprojection. The presenter blits the frame submitted last once `vrcompositor`'s GPU diff --git a/docs/desktop-uninstall.md b/docs/desktop-uninstall.md new file mode 100644 index 0000000000..dd9c5f6746 --- /dev/null +++ b/docs/desktop-uninstall.md @@ -0,0 +1,13 @@ +# Uninstall desktop mode + +Choose **Uninstall** beside **Open desktop**, then confirm. The same action is available under +**Desktop → Files**. Stop any running session and let other installs finish first. + +Removal keeps Steam, games, added apps, settings, modified files and shared dependencies. It uses +the pinned desktop file inventory and only removes matching files. Unknown desktop versions and +missing runtime package ownership cause removal to fail before deleting files. + +An interrupted desktop install also offers Uninstall. Successful removal clears that desktop +installation's recovery record and cached download so the next guest launch cannot reinstall it +through package recovery. If removal is interrupted, choose Uninstall again to retry. Open desktop +installs the desktop again when needed. diff --git a/docs/development/added-games.md b/docs/development/added-games.md index 9e1566dd43..c39ae8d144 100644 --- a/docs/development/added-games.md +++ b/docs/development/added-games.md @@ -95,7 +95,7 @@ scan (`Library.launchableGames`) compares the folder with what was last written (`grid-` in the game's art folder): a file Steam changed becomes the choice (source Steam), a file removed in Steam drops it, and files the shortcuts writer placed itself (`.droiddeck-art.json`) are not mistaken for choices. A chosen image is stored as -`chosen--