Merge branch 'Fix-Vibration'

# Conflicts:
#	app/src/main/cpp/extras/evshim.c
#	app/src/main/java/app/gamenative/ui/component/dialog/ControllerTab.kt
#	app/src/main/java/app/gamenative/ui/screen/xserver/XServerScreen.kt

Author: TideGear

README.md

@@ -7,8 +7,6 @@ GameNative allows you to play games you own on Steam, Epic and GOG directly on A
 
 [Playing Stray on Poco F6](https://github.com/user-attachments/assets/1870fd14-7de9-4054-ba92-d3a5c73686b5)
 
-This is a fork of [Pluvia](https://github.com/oxters168/Pluvia), a Steam client for Android.
-
 ## How to Use
 
 (Note that GameNative is still in its early stages, and all games may not work, or may require tweaking to get working well)
@@ -42,6 +40,8 @@ Join our [Discord server](https://discord.gg/2hKv4VfZfE) for support and updates
 ## License
 [GPL 3.0](https://github.com/utkarshdalal/GameNative/blob/master/LICENSE)
 
+See [THIRD_PARTY_NOTICES](THIRD_PARTY_NOTICES) for attributions, copyleft source offers, and notices about third-party and proprietary components bundled with the application.
+
 ## Analytics & Privacy
 
 GameNative uses [PostHog](https://posthog.com) for anonymous analytics. No personal information is ever collected — no names, emails, IPs, or device identifiers.

THIRD_PARTY_NOTICES

@@ -4,6 +4,104 @@ This file contains notices for third-party assets and libraries used in this pro
 
 ---
 
+## Scope and Completeness
+
+This list is **not exhaustive**. GameNative builds on the broader open-source
+Wine / Proton / DXVK / VKD3D / Mesa / box64 / FEX / PulseAudio ecosystem, and
+additional smaller components may be present in bundled archives under
+`app/src/main/assets/` and prebuilt native libraries under
+`app/src/main/jniLibs/`. Where a component is distributed under a copyleft
+license (LGPL, GPL, MPL), the terms of that license apply regardless of whether
+the component is named in this file. The sections below highlight the items
+that most users will want to know about, together with a blanket offer for the
+corresponding source of any copyleft component we distribute in binary form.
+
+---
+
+## Availability of Source for Copyleft Components
+
+For any component distributed in binary form with this application that is
+covered by a copyleft license (LGPL-2.1, LGPL-3.0, GPL-2.0, GPL-3.0, or
+MPL-2.0), the corresponding source code is available from the upstream project
+at the revision used. Where practical, the upstream name and revision are
+recorded alongside the binary — for example in `VERSION` / `COMMIT` metadata
+inside the bundled archive, in the filename of the archive itself, or in
+`app/src/main/cpp/` for components built from source in this repository.
+
+If you cannot obtain the source from upstream, contact
+Utkarsh Dalal on our
+[Discord server](https://discord.gg/2hKv4VfZfE)) and we will supply it, in
+accordance with LGPL-2.1 §6, LGPL-3.0 §4, GPL-2.0 §3, and GPL-3.0 §6. This
+offer is valid for at least three years from the date on which you received
+the binary.
+
+---
+
+## libredirect.so (Proprietary)
+
+**Component:** `libredirect.so`
+**Location:** `app/src/main/assets/redirect.tzst`
+**License:** Proprietary — all rights reserved by the GameNative maintainers.
+
+`libredirect.so` is a small native shim developed by the GameNative
+maintainers. It is loaded **only into Wine / Proton subprocesses** at runtime
+via `LD_PRELOAD`; it is not linked with, and does not run inside the address
+space of, the Kotlin/Java Android application. Its responsibilities are:
+
+1. **Identifier compatibility.** Some guest-side components embed the
+   historical Android package identifier `com.winlator`. `libredirect.so`
+   rewrites those references to the current application identifier at runtime
+   so that games which hardcode or capture the identifier during launch
+   continue to boot correctly under GameNative.
+2. **Android 15 (API 35) compatibility.** Recent Android releases tightened
+   restrictions on how executables stored under an app's private data
+   directory may be invoked. `libredirect.so` adapts affected process
+   launches so that the emulation stack continues to function on Android 15
+   and later.
+
+`libredirect.so` was written from scratch by the GameNative maintainers and
+is not derived from any code in this repository. It is kept closed-source
+for a specific reason. AI-assisted and commercial forks routinely take
+open-source Android projects, rename them, and redistribute them through
+commercial channels as their own products. Because `libredirect.so` is
+specific to this application — not a generic tool that a fork could use
+unchanged — publishing its source would reduce rebranding GameNative into
+a working fork to a near-trivial operation. Keeping it closed raises the
+cost of that path substantially. Every other component in this repository
+— the application UI, store integrations, container management, device
+configuration, and all code the community actively contributes to —
+remains fully open under GPL-3.0 and may be forked, modified, and
+redistributed under those terms.
+
+### Relationship to the GPL-3.0 application
+
+GameNative's Kotlin/Java application is distributed under GPL-3.0 and remains
+so. `libredirect.so` runs inside separate subprocesses (Wine and Proton
+instances) and communicates with those processes through standard
+operating-system interfaces only. It is not compiled or linked into the
+Android application, does not share the Android application's address space,
+and does not expose a library interface to it. Under the FSF's and SFLC's
+longstanding interpretation of the GPL's "mere aggregation" language
+(GPL-3.0 §5, GPL-2.0 §2), this makes `libredirect.so` a separate program
+aggregated with GameNative on the same distribution medium rather than a
+derivative work of the application.
+
+### Separability
+
+The GameNative application can be rebuilt without `libredirect.so` by
+deleting `app/src/main/assets/redirect.tzst` before building the APK. The
+resulting GPL-3.0 application builds, installs, and runs as a standalone
+program; it does not require `libredirect.so` to be compiled or linked.
+Practical runtime compatibility will be reduced: on Android 15 and later,
+most Windows games launched through the bundled emulation stack will fail
+to start, and on earlier Android versions some games that embed the
+historical `com.winlator` identifier will fail to receive input. This
+reflects GPL's guarantee that users can modify and rebuild the application
+itself; it does not imply that `libredirect.so` is part of the application
+in the sense of GPL-3.0 §0 ("based on").
+
+---
+
 ## Kenney Input Prompts
 
 **Asset Pack:** Input Prompts

app/src/main/cpp/extras/evshim.c

@@ -7,14 +7,14 @@
 #include <dlfcn.h>
 #include <fcntl.h>
 #include <errno.h>
+#include <stddef.h>
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <pthread.h>
 #include <unistd.h>
 #include <SDL2/SDL.h>
 #include <stdarg.h>
-#include <stdatomic.h>
 #include <sys/inotify.h>
 #include <poll.h>
 #include <time.h>
@@ -32,10 +32,12 @@ static int rumble_fd[MAX_GAMEPADS] = {-1};
 static void *handle = NULL;
 static pthread_mutex_t shm_mutex = PTHREAD_MUTEX_INITIALIZER;
 
-/* Set to 1 on the player index being refreshed by the SDL keepalive so that
- * the resulting re-entrant OnRumble() call does not overwrite shared memory
- * (which may have been zeroed by a stop command that raced the keepalive). */
-static atomic_int g_keepalive_active[MAX_GAMEPADS];
+/* Set to 1 on the keepalive thread before calling SDL_JoystickRumble so the
+ * resulting synchronous (same-thread) re-entrant OnRumble() call does not
+ * overwrite shared memory (which may have been zeroed by a stop command that
+ * raced the keepalive). Thread-local so legitimate OnRumble calls from other
+ * threads are never suppressed. */
+static __thread int t_keepalive_active = 0;
 
 struct gamepad_io {
     int16_t lx, ly, rx, ry, lt, rt;
@@ -89,7 +91,7 @@ static int OnRumble(void *userdata,
      * We must NOT update last_rumble or pwrite in that case: the game may
      * have already sent OnRumble(0,0) to stop vibration, and re-writing
      * the old non-zero values would restart rumble on the Android side. */
-    if (atomic_load(&g_keepalive_active[idx])) {
+    if (t_keepalive_active) {
         LOGD("Rumble P%d  low=%u  high=%u [keepalive noop]\n", idx,
              low_frequency_rumble, high_frequency_rumble);
         return 0;
@@ -179,7 +181,7 @@ static void *vjoy_updater(void *arg)
         ssize_t n = pread(fd, &cur, sizeof cur, 0);
         pthread_mutex_unlock(&shm_mutex);
 
-        if (n == sizeof cur && memcmp(&cur, &last_state, sizeof cur) != 0) {
+        if (n == sizeof cur && memcmp(&cur, &last_state, offsetof(struct gamepad_io, low_freq_rumble)) != 0) {
 
             p_SDL_JoystickSetVirtualAxis (js, 0, cur.lx);
             p_SDL_JoystickSetVirtualAxis (js, 1, cur.ly);
@@ -220,9 +222,9 @@ static void *vjoy_updater(void *arg)
                     /* Flag this player's slot before calling SDL so that the
                      * synchronous OnRumble() re-entry is recognised as a
                      * keepalive and does not overwrite shared memory. */
-                    atomic_store(&g_keepalive_active[idx], 1);
+                    t_keepalive_active = 1;
                     p_SDL_JoystickRumble(js, kl, kh, RUMBLE_KEEPALIVE_DUR_MS);
-                    atomic_store(&g_keepalive_active[idx], 0);
+                    t_keepalive_active = 0;
                     LOGD("Rumble keepalive P%d  low=%u  high=%u\n", idx, kl, kh);
                 }
             }
@@ -241,10 +243,6 @@ static void *vjoy_updater(void *arg)
             p_SDL_Delay(5);
         }
     }
-
-    /* Unreachable in normal operation; cleanup for early-return paths above. */
-    if (ino_fd >= 0) close(ino_fd);
-    return NULL;
 }
 
 __attribute__((constructor))

app/src/main/java/app/gamenative/service/SteamService.kt

@@ -173,6 +173,7 @@ import app.gamenative.statsgen.Achievement
 import app.gamenative.statsgen.StatType
 import app.gamenative.statsgen.StatsAchievementsGenerator
 import app.gamenative.statsgen.VdfParser
+import app.gamenative.utils.DownloadSpeedConfig
 import java.nio.ByteBuffer
 import java.nio.ByteOrder
 
@@ -1657,34 +1658,11 @@ class SteamService : Service(), IChallengeUrlChanged {
                             return@launch
                         }
 
-                        // Some notes here:
-                        // Write should always be 1 in mobile device, as normally it does not use a SSD for storage
-                        // And to have maximum throughput, set downloadRatio = decompressRatio = 1.0 x CPU Cores
-                        var downloadRatio = 0.0
-                        var decompressRatio = 0.0
-
-                        when (PrefManager.downloadSpeed) {
-                            8 -> {
-                                downloadRatio = 0.6
-                                decompressRatio = 0.2
-                            }
-                            16 -> {
-                                downloadRatio = 1.2
-                                decompressRatio = 0.4
-                            }
-                            24 -> {
-                                downloadRatio = 1.5
-                                decompressRatio = 0.5
-                            }
-                            32 -> {
-                                downloadRatio = 2.4
-                                decompressRatio = 0.8
-                            }
-                        }
-
-                        val cpuCores = Runtime.getRuntime().availableProcessors()
-                        val maxDownloads = (cpuCores * downloadRatio).toInt().coerceAtLeast(1)
-                        val maxDecompress = (cpuCores * decompressRatio).toInt().coerceAtLeast(1)
+                        // Moved to DownloadSpeedConfig
+                        val speedConfig = DownloadSpeedConfig()
+                        val cpuCores = speedConfig.cpuCores
+                        val maxDownloads = speedConfig.maxDownloads
+                        val maxDecompress = speedConfig.maxDecompress
 
                         Timber.i("CPU Cores: $cpuCores")
                         Timber.i("maxDownloads: $maxDownloads")