From 6a5dfe14864c9d0658710d7e0899bfdfedfc1ae6 Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Mon, 26 Oct 2026 12:32:35 -0400 Subject: [PATCH 1/6] feat(steam): sync QAM brightness and volume with Android --- app/src/main/AndroidManifest.xml | 2 + .../launcher/audio/PulseAudioComponent.java | 7 +- .../runtime/DeviceControlsComponent.kt | 177 ++++++++++++++++++ .../launcher/runtime/LinuxRuntime.java | 1 + .../launcher/session/SessionService.kt | 4 + .../runtime/DeviceControlsComponentTest.kt | 120 ++++++++++++ tools/aaudio-sink/android-volume.h | 96 ++++++++++ tools/aaudio-sink/module-aaudio-sink.c | 10 + .../sink/module-directaudio-native-sink.c | 10 + .../usr/local/bin/droiddeck-steam-compat | 73 +++++++- tools/tests/test_device_controls.py | 82 ++++++++ 11 files changed, 575 insertions(+), 7 deletions(-) create mode 100644 app/src/main/java/com/droiddeck/launcher/runtime/DeviceControlsComponent.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/runtime/DeviceControlsComponentTest.kt create mode 100644 tools/aaudio-sink/android-volume.h create mode 100644 tools/tests/test_device_controls.py diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 1ce7b0ac73..6336fb1325 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -27,6 +27,8 @@ + + diff --git a/app/src/main/java/com/droiddeck/launcher/audio/PulseAudioComponent.java b/app/src/main/java/com/droiddeck/launcher/audio/PulseAudioComponent.java index 3b73b6a3c9..32d5f5189e 100644 --- a/app/src/main/java/com/droiddeck/launcher/audio/PulseAudioComponent.java +++ b/app/src/main/java/com/droiddeck/launcher/audio/PulseAudioComponent.java @@ -26,6 +26,7 @@ public class PulseAudioComponent extends SessionPart { private final File workingDir; + private final File deviceControls; private File logFile; private final String micFifoPath; private volatile int pid = -1; @@ -36,6 +37,8 @@ public class PulseAudioComponent extends SessionPart { public PulseAudioComponent(Context context, String micFifoPath) { this.workingDir = new File(context.getFilesDir(), "pulseaudio"); + this.deviceControls = com.droiddeck.launcher.runtime.DeviceControlsComponent.directory( + com.droiddeck.launcher.runtime.LinuxRuntime.rootDir(context)); this.micFifoPath = micFifoPath; } @@ -94,7 +97,7 @@ public class PulseAudioComponent extends SessionPart { config.add("load-module module-native-protocol-unix auth-anonymous=1 auth-cookie-enabled=0 socket=\"" + socket().getAbsolutePath() + "\""); config.add(".nofail"); - config.add("load-module module-directaudio-native-sink sink_name=DirectAudio performance_mode=1 adaptive=1 decay=0 limiter=1 watchdog=1 volume=1.0"); + config.add("load-module module-directaudio-native-sink sink_name=DirectAudio performance_mode=1 adaptive=1 decay=0 limiter=1 watchdog=1 volume=1.0 control_dir=" + deviceControls); config.add("set-default-sink DirectAudio"); config.add(".fail"); if (micFifoPath != null && !micFifoPath.isEmpty()) { @@ -139,7 +142,7 @@ public class PulseAudioComponent extends SessionPart { } else if (sinks.contains("\tDirectAudio\t") || sinks.startsWith("DirectAudio\t") || sinks.contains("\tDirectAudio\n") || sinks.matches("(?s).*\\bDirectAudio\\b.*")) { line = "== client sink: DirectAudio (module-directaudio-native-sink)"; } else { - boolean loaded = pactl("load-module", "module-aaudio-sink", "sink_name=AAudioSink", "performance_mode=1", "adaptive=1", "volume=1.0") != null + boolean loaded = pactl("load-module", "module-aaudio-sink", "sink_name=AAudioSink", "performance_mode=1", "adaptive=1", "volume=1.0", "control_dir=" + deviceControls) != null && pactl("set-default-sink", "AAudioSink") != null; line = loaded ? "== client sink: DirectAudio did not come up; FALLBACK to the plain AAudio sink (AAudioSink)" : "== client sink: DirectAudio did not come up and the AAudio fallback failed too - no client sound"; diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/DeviceControlsComponent.kt b/app/src/main/java/com/droiddeck/launcher/runtime/DeviceControlsComponent.kt new file mode 100644 index 0000000000..c88666dfb5 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/runtime/DeviceControlsComponent.kt @@ -0,0 +1,177 @@ +package com.droiddeck.launcher.runtime + +import android.content.Context +import android.content.Intent +import android.database.ContentObserver +import android.media.AudioManager +import android.net.Uri +import android.os.FileObserver +import android.os.Handler +import android.os.Looper +import android.os.SystemClock +import android.provider.Settings +import android.util.Log +import com.droiddeck.launcher.core.SessionPart +import java.io.File +import java.nio.file.Files +import java.nio.file.StandardCopyOption +import org.json.JSONObject +import kotlin.math.roundToInt + +class DeviceControlsComponent(context: Context, root: File) : SessionPart() { + private val context = context.applicationContext + private val audio = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager + private val directory = directory(root) + private val handler = Handler(Looper.getMainLooper()) + private var running = false + private var pendingBrightness: Pair? = null + private var permissionRequestAt = -5_000L + private var previous = "" + private var revision = 0L + init { prepareBacklight(context, root) } + private val observer = object : ContentObserver(handler) { + override fun onChange(selfChange: Boolean) { if (running) publish() } + } + private val requests = object : FileObserver(directory.path, CLOSE_WRITE or MOVED_TO) { + override fun onEvent(event: Int, path: String?) { + if (path in REQUESTS) handler.post { if (running) consume() } + } + } + private val refresh = object : Runnable { + override fun run() { + if (!running) return + consume() + pendingBrightness?.let { (value, time) -> + if (SystemClock.elapsedRealtime() - time > 120_000) pendingBrightness = null + else if (Settings.System.canWrite(context)) { + pendingBrightness = null + brightness(value) + } + } + publish() + handler.postDelayed(this, 250) + } + } + + fun publish(force: Boolean = false) { + try { + directory.mkdirs() + val level = audio.getStreamVolume(AudioManager.STREAM_MUSIC) + val maximum = audio.getStreamMaxVolume(AudioManager.STREAM_MUSIC).coerceAtLeast(1) + val muted = audio.isStreamMute(AudioManager.STREAM_MUSIC) + write("volume.state", "$level $maximum ${if (muted) 1 else 0}\n") + val value = Settings.System.getInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS, 128) + write("backlight/droiddeck/brightness", "$value\n") + write("backlight/droiddeck/actual_brightness", "$value\n") + val state = JSONObject().put("brightness", (value.coerceIn(1, 255) - 1) / 254.0) + .put("brightnessWritable", Settings.System.canWrite(context)).toString() + if (force || state != previous) { + write("state.json", JSONObject(state).put("revision", ++revision).toString()) + previous = state + } + } catch (e: Exception) { + Log.w(TAG, "Could not publish Android controls", e) + } + } + + override fun start() { + handler.post { + REQUESTS.forEach { + File(directory, it).delete() + File(directory, "$it.processing").delete() + } + running = true + context.contentResolver.registerContentObserver(Settings.System.CONTENT_URI, true, observer) + requests.startWatching() + refresh.run() + } + } + + override fun stop() { + handler.post { + running = false + handler.removeCallbacks(refresh) + requests.stopWatching() + context.contentResolver.unregisterContentObserver(observer) + pendingBrightness = null + } + } + + private fun consume() { + for (name in REQUESTS) { + val file = File(directory, name) + if (!file.isFile) continue + val claimed = File(directory, "$name.processing") + try { + Files.move(file.toPath(), claimed.toPath(), StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE) + if (claimed.length() > 64) continue + val text = claimed.readText().trim() + when (name) { + "brightness.request" -> text.toFloatOrNull()?.takeIf { it.isFinite() && it in 0f..1f }?.let(::brightness) + "volume.request" -> text.toIntOrNull()?.let { + audio.setStreamVolume(AudioManager.STREAM_MUSIC, + it.coerceIn(0, audio.getStreamMaxVolume(AudioManager.STREAM_MUSIC)), 0) + } + "mute.request" -> if (text == "0" || text == "1") { + audio.adjustStreamVolume(AudioManager.STREAM_MUSIC, + if (text == "1") AudioManager.ADJUST_MUTE else AudioManager.ADJUST_UNMUTE, 0) + } + } + } catch (e: Exception) { + Log.w(TAG, "Could not apply $name", e) + } finally { + publish(force = true) + claimed.delete() + } + } + } + + private fun brightness(value: Float) { + if (!Settings.System.canWrite(context)) { + pendingBrightness = value to SystemClock.elapsedRealtime() + val now = SystemClock.elapsedRealtime() + if (now - permissionRequestAt >= 5_000) { + permissionRequestAt = now + try { + context.startActivity(Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS, + Uri.parse("package:${context.packageName}")).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)) + } catch (e: Exception) { + Log.w(TAG, "Could not open brightness permission", e) + } + } + return + } + val level = 1 + (value * 254).roundToInt() + try { + Settings.System.putInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS_MODE, + Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL) + Settings.System.putInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS, level) + } catch (e: SecurityException) { + Log.w(TAG, "Brightness permission was revoked", e) + } + } + + private fun write(name: String, text: String) { + val file = File(directory, name) + if (file.isFile && file.readText() == text) return + val staged = File(directory, "$name.tmp") + staged.writeText(text) + Files.move(staged.toPath(), file.toPath(), StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE) + } + + companion object { + private const val TAG = "DeviceControls" + private val REQUESTS = setOf("brightness.request", "volume.request", "mute.request") + @JvmStatic fun directory(root: File) = File(root, "etc/droiddeck-device-controls") + @JvmStatic fun prepareBacklight(context: Context, root: File): File { + val base = File(directory(root), "backlight") + val panel = File(base, "droiddeck").apply { mkdirs() } + val value = Settings.System.getInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS, 128) + for ((name, text) in mapOf("type" to "raw", "max_brightness" to "255", "brightness" to "$value", + "actual_brightness" to "$value", "bl_power" to "0", "scale" to "linear")) { + File(panel, name).writeText("$text\n") + } + return base + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java index 6473197549..d02fdf0c2f 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java +++ b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java @@ -192,6 +192,7 @@ public final class LinuxRuntime { bind(cmd, "/dev"); bind(cmd, "/proc"); bind(cmd, "/sys"); + bind(cmd, DeviceControlsComponent.prepareBacklight(context, root).getPath() + ":/sys/class/backlight"); bind(cmd, "/dev/urandom:/dev/random"); bind(cmd, "/proc/self/fd:/dev/fd"); bind(cmd, "/proc/self/fd/0:/dev/stdin"); 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 b6f35f96a1..252f94103f 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -630,6 +630,10 @@ class SessionService : Service() { networkLink.attach(this) networkLink.publish() components.add(networkLink) + val deviceControls = com.droiddeck.launcher.runtime.DeviceControlsComponent(this, root) + deviceControls.attach(this) + deviceControls.publish() + components.add(deviceControls) if (gen != sessionGen || !SessionState.running) { Log.i(TAG, "session stopped while it was starting; not launching it") if (gen == sessionGen) components.clear() diff --git a/app/src/test/java/com/droiddeck/launcher/runtime/DeviceControlsComponentTest.kt b/app/src/test/java/com/droiddeck/launcher/runtime/DeviceControlsComponentTest.kt new file mode 100644 index 0000000000..9e0da30aa7 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/runtime/DeviceControlsComponentTest.kt @@ -0,0 +1,120 @@ +package com.droiddeck.launcher.runtime + +import android.app.Application +import android.content.Context +import android.media.AudioManager +import android.os.Looper +import android.provider.Settings +import java.io.File +import java.time.Duration +import org.json.JSONObject +import org.junit.After +import org.junit.Assert.* +import org.junit.Before +import org.junit.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config +import org.robolectric.annotation.Implements +import org.robolectric.annotation.Implementation +import org.robolectric.shadows.ShadowSettings + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE, application = Application::class, shadows = [WriteSettingsShadow::class]) +class DeviceControlsComponentTest { + @get:Rule val tmp = TemporaryFolder() + private val context get() = RuntimeEnvironment.getApplication() + private val audio get() = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager + private lateinit var component: DeviceControlsComponent + private lateinit var directory: File + + @Before fun start() { + WriteSettingsShadow.writable = true + Settings.System.putInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS, 128) + val root = tmp.newFolder() + directory = DeviceControlsComponent.directory(root) + component = DeviceControlsComponent(context, root) + component.publish() + component.start() + shadowOf(Looper.getMainLooper()).idle() + } + + @After fun stop() { + component.stop() + shadowOf(Looper.getMainLooper()).idle() + } + + private fun tick() = shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(300)) + private fun request(name: String, text: String) { + File(directory, "$name.request").writeText(text) + tick() + } + + @Test fun androidChangesArePublishedAndRequestsUseDeviceVolumeSteps() { + request("volume", "999") + assertEquals(audio.getStreamMaxVolume(AudioManager.STREAM_MUSIC), audio.getStreamVolume(AudioManager.STREAM_MUSIC)) + audio.setStreamVolume(AudioManager.STREAM_MUSIC, 3, 0) + tick() + assertEquals("3", File(directory, "volume.state").readText().split(" ").first()) + request("volume", "invalid") + assertEquals(3, audio.getStreamVolume(AudioManager.STREAM_MUSIC)) + } + + @Test fun deniedBrightnessIsReadBackAndAppliedOnlyAfterPermission() { + WriteSettingsShadow.writable = false + request("brightness", "0.75") + assertEquals(128, Settings.System.getInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS)) + assertEquals(Settings.ACTION_MANAGE_WRITE_SETTINGS, shadowOf(context).nextStartedActivity.action) + assertFalse(JSONObject(File(directory, "state.json").readText()).getBoolean("brightnessWritable")) + WriteSettingsShadow.writable = true + tick() + assertEquals(192, Settings.System.getInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS)) + } + + @Test fun brightnessIsBoundedAndExternalChangesAreReadBack() { + for (invalid in listOf("NaN", "Infinity", "-0.1", "1.1")) request("brightness", invalid) + assertEquals(128, Settings.System.getInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS)) + request("brightness", "0") + assertEquals(1, Settings.System.getInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS)) + Settings.System.putInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS, 255) + tick() + assertEquals(1.0, JSONObject(File(directory, "state.json").readText()).getDouble("brightness"), 0.0001) + } + + @Test fun stoppedSessionsDoNotConsumeNewCommands() { + component.stop() + shadowOf(Looper.getMainLooper()).idle() + request("brightness", "0.2") + assertEquals(128, Settings.System.getInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS)) + } + + @Test fun rejectedPermissionCanBeRequestedAgainWithoutOpeningRepeatedScreens() { + WriteSettingsShadow.writable = false + request("brightness", "0.75") + assertNotNull(shadowOf(context).nextStartedActivity) + request("brightness", "0.8") + assertNull(shadowOf(context).nextStartedActivity) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(5)) + request("brightness", "0.8") + assertNotNull(shadowOf(context).nextStartedActivity) + } + + @Test fun oversizedRequestsAreDiscardedAndDoNotBlockLaterCommands() { + request("brightness", "0".repeat(1000)) + assertFalse(File(directory, "brightness.request.processing").exists()) + request("brightness", "0.75") + assertEquals(192, Settings.System.getInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS)) + } +} + +@Implements(Settings.System::class) +class WriteSettingsShadow : ShadowSettings.ShadowSystem() { + companion object { + @JvmField var writable = true + @JvmStatic @Implementation fun canWrite(context: Context) = writable + } +} diff --git a/tools/aaudio-sink/android-volume.h b/tools/aaudio-sink/android-volume.h new file mode 100644 index 0000000000..b7f4ec9d18 --- /dev/null +++ b/tools/aaudio-sink/android-volume.h @@ -0,0 +1,96 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +#include +#include + +struct android_volume { + pa_sink *sink; + char *directory; + pa_time_event *timer; +}; + +static bool android_volume_read(const char *directory, unsigned *level, unsigned *maximum, unsigned *muted) { + char *path = pa_sprintf_malloc("%s/volume.state", directory); + FILE *file = fopen(path, "r"); + pa_xfree(path); + if (!file) return false; + int fields = fscanf(file, "%u %u %u", level, maximum, muted); + fclose(file); + return fields == 3 && *maximum > 0 && *level <= *maximum && *muted <= 1; +} + +static void android_volume_request(pa_sink *sink, const char *name, unsigned value) { + struct userdata *u = sink->userdata; + if (!u->android_volume || sink->state == PA_SINK_INIT) return; + char *path = pa_sprintf_malloc("%s/%s.request", u->android_volume->directory, name); + char *staged = pa_sprintf_malloc("%s.tmp", path); + FILE *file = fopen(staged, "w"); + if (file) { + fprintf(file, "%u\n", value); + if (fclose(file) == 0 && rename(staged, path) < 0) pa_log_warn("Could not publish Android %s", name); + } + pa_xfree(staged); + pa_xfree(path); +} + +static void android_volume_set(pa_sink *sink) { + struct userdata *u = sink->userdata; + unsigned level, maximum, muted; + if (!u->android_volume || !android_volume_read(u->android_volume->directory, &level, &maximum, &muted)) return; + unsigned requested = PA_MIN(pa_cvolume_max(&sink->real_volume), PA_VOLUME_NORM); + level = ((uint64_t)requested * maximum + PA_VOLUME_NORM / 2) / PA_VOLUME_NORM; + pa_cvolume_set(&sink->real_volume, sink->sample_spec.channels, (uint64_t)level * PA_VOLUME_NORM / maximum); + /* Android applies media gain to both PulseAudio and DirectAudio streams. */ + pa_cvolume_reset(&sink->soft_volume, sink->sample_spec.channels); + android_volume_request(sink, "volume", level); +} + +static void android_volume_mute(pa_sink *sink) { + android_volume_request(sink, "mute", sink->muted ? 1 : 0); +} + +static void android_volume_refresh(pa_mainloop_api *api, pa_time_event *event, const struct timeval *tv, void *userdata) { + struct android_volume *bridge = userdata; + unsigned level, maximum, muted; + char *request = pa_sprintf_malloc("%s/volume.request", bridge->directory); + char *mute_request = pa_sprintf_malloc("%s/mute.request", bridge->directory); + char *processing = pa_sprintf_malloc("%s.processing", request); + char *mute_processing = pa_sprintf_malloc("%s.processing", mute_request); + if (access(request, F_OK) != 0 && access(mute_request, F_OK) != 0 && + access(processing, F_OK) != 0 && access(mute_processing, F_OK) != 0 && + android_volume_read(bridge->directory, &level, &maximum, &muted)) { + pa_cvolume volume; + pa_cvolume_set(&volume, bridge->sink->sample_spec.channels, (uint64_t)level * PA_VOLUME_NORM / maximum); + if (!pa_cvolume_equal(&volume, &bridge->sink->real_volume)) pa_sink_volume_changed(bridge->sink, &volume); + if (bridge->sink->muted != !!muted) pa_sink_mute_changed(bridge->sink, !!muted); + } + pa_xfree(request); + pa_xfree(mute_request); + pa_xfree(processing); + pa_xfree(mute_processing); + pa_core_rttime_restart(bridge->sink->core, event, pa_rtclock_now() + 100 * PA_USEC_PER_MSEC); +} + +static struct android_volume *android_volume_new(pa_sink *sink, const char *directory) { + unsigned level, maximum, muted; + if (!directory || !android_volume_read(directory, &level, &maximum, &muted)) return NULL; + struct android_volume *bridge = pa_xnew0(struct android_volume, 1); + bridge->sink = sink; + bridge->directory = pa_xstrdup(directory); + pa_cvolume_set(&sink->real_volume, sink->sample_spec.channels, (uint64_t)level * PA_VOLUME_NORM / maximum); + sink->reference_volume = sink->real_volume; + sink->muted = !!muted; + sink->n_volume_steps = maximum + 1; + pa_cvolume_reset(&sink->soft_volume, sink->sample_spec.channels); + pa_sink_set_set_volume_callback(sink, android_volume_set); + pa_sink_set_set_mute_callback(sink, android_volume_mute); + bridge->timer = pa_core_rttime_new(sink->core, pa_rtclock_now() + 100 * PA_USEC_PER_MSEC, + android_volume_refresh, bridge); + return bridge; +} + +static void android_volume_free(struct android_volume *bridge) { + if (!bridge) return; + bridge->sink->core->mainloop->time_free(bridge->timer); + pa_xfree(bridge->directory); + pa_xfree(bridge); +} diff --git a/tools/aaudio-sink/module-aaudio-sink.c b/tools/aaudio-sink/module-aaudio-sink.c index 619bd26733..3c129ce4b6 100644 --- a/tools/aaudio-sink/module-aaudio-sink.c +++ b/tools/aaudio-sink/module-aaudio-sink.c @@ -42,6 +42,7 @@ PA_MODULE_USAGE( "channels= " "channel_map= " "volume= " + "control_dir= " "performance_mode=<0 none, 1 low latency, 2 power saving> " "adaptive= " "buffer_frames= " @@ -56,6 +57,7 @@ PA_MODULE_USAGE( #define STATS_EVERY_USEC (30 * PA_USEC_PER_SEC) static const char* const valid_modargs[] = { + "control_dir", "sink_name", "sink_properties", "format", @@ -70,7 +72,10 @@ static const char* const valid_modargs[] = { NULL }; +struct android_volume; + struct userdata { + struct android_volume *android_volume; pa_core *core; pa_module *module; pa_sink *sink; @@ -100,6 +105,9 @@ struct userdata { int32_t xruns_reported; }; +#include "android-volume.h" + + static pa_usec_t frames_to_usec(const struct userdata *u, int64_t frames) { return (pa_usec_t) (frames * (int64_t) PA_USEC_PER_SEC / (int64_t) u->ss.rate); } @@ -472,6 +480,7 @@ int pa__init(pa_module *m) { goto fail; } + u->android_volume = android_volume_new(u->sink, pa_modargs_get_value(ma, "control_dir", NULL)); pa_sink_put(u->sink); pa_modargs_free(ma); return 0; @@ -498,6 +507,7 @@ void pa__done(pa_module *m) { if (!(u = m->userdata)) return; + android_volume_free(u->android_volume); if (u->sink) pa_sink_unlink(u->sink); if (u->thread) { diff --git a/tools/directaudio/sink/module-directaudio-native-sink.c b/tools/directaudio/sink/module-directaudio-native-sink.c index ca3eb01cc5..4d03e6bd4d 100644 --- a/tools/directaudio/sink/module-directaudio-native-sink.c +++ b/tools/directaudio/sink/module-directaudio-native-sink.c @@ -59,6 +59,7 @@ PA_MODULE_DESCRIPTION("Android audio output: DirectAudio's AAudio engine, in-pro PA_MODULE_VERSION(PACKAGE_VERSION); PA_MODULE_LOAD_ONCE(false); PA_MODULE_USAGE( + "control_dir= " "sink_name= " "sink_properties= " "volume= " @@ -91,11 +92,15 @@ PA_MODULE_USAGE( #define DA_FADE_FRAMES 64 static const char* const valid_modargs[] = { + "control_dir", "sink_name", "sink_properties", "volume", "performance_mode", "buffer_ms", "max_ms", "ring_ms", "adaptive", "decay", "limiter", "watchdog", NULL }; +struct android_volume; + struct userdata { + struct android_volume *android_volume; pa_core *core; pa_module *module; pa_sink *sink; @@ -136,6 +141,9 @@ struct userdata { unsigned int opens; }; +#include "../../aaudio-sink/android-volume.h" + + static uint64_t now_ns(void) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); @@ -774,6 +782,7 @@ int pa__init(pa_module *m) { pa_log("Failed to create thread."); goto fail; } + u->android_volume = android_volume_new(u->sink, pa_modargs_get_value(ma, "control_dir", NULL)); pa_sink_put(u->sink); pa_modargs_free(ma); return 0; @@ -799,6 +808,7 @@ void pa__done(pa_module *m) { pa_assert(m); if (!(u = m->userdata)) return; + android_volume_free(u->android_volume); if (u->sink) pa_sink_unlink(u->sink); if (u->thread) { diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat index ba739235b1..595563019b 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat @@ -2,6 +2,7 @@ import base64 import ctypes import json +import math import os import runpy import select @@ -15,6 +16,48 @@ import time HERE = os.path.dirname(os.path.realpath(__file__)) COMPAT = runpy.run_path(os.path.join(HERE, "steam-compatibility")) BINDING = "droiddeckCompatChanged" +BRIGHTNESS_BINDING = "droiddeckBrightnessChanged" +CONTROLS_DIR = "/etc/droiddeck-device-controls" +BRIGHTNESS_JS = r""" +(() => { + if (window.__droiddeckBrightness) return "present"; + const display = SteamClient.System?.Display; + if (!display?.RegisterForBrightnessChanges || !display?.SetBrightness) return "unavailable"; + const self = { expected: null, updating: true }; + self.set = value => { + if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) return; + if (!self.updating && self.expected !== null && Math.abs(value - self.expected) < 0.0001) return; + self.expected = value; + self.updating = true; + display.SetBrightness(value); + }; + self.subscription = display.RegisterForBrightnessChanges(state => { + const value = state?.flBrightness; + if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1 || self.expected === null) return; + if (Math.abs(value - self.expected) < 0.0001) { self.updating = false; return; } + if (self.updating) return; + self.expected = value; + if (typeof window.__BINDING__ === "function") window.__BINDING__(String(value)); + }); + window.__droiddeckBrightness = self; + return "installed"; +})() +""".replace("__BINDING__", BRIGHTNESS_BINDING) + + +def brightness_request(payload, directory=CONTROLS_DIR): + try: + value = float(payload) + if not math.isfinite(value) or not 0 <= value <= 1: + return + path = os.path.join(directory, "brightness.request") + with open(path + ".tmp", "w") as target: + target.write(str(value) + "\n") + os.replace(path + ".tmp", path) + except (ValueError, TypeError, OSError): + return + + INSTALL_JS = r""" (() => { if (window.__droiddeckCompat) return "present"; @@ -633,6 +676,20 @@ class Helper: self.tools_checked = None self.vr_launch = None self.chooser = None + self.controls_state = None + + def sync_controls(self): + try: + with open(os.path.join(CONTROLS_DIR, "state.json")) as source: + state = json.load(source) + value = state.get("brightness") + if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value) or not 0 <= value <= 1: + return + if state != self.controls_state: + self.page.evaluate("window.__droiddeckBrightness?.set(%s)" % json.dumps(value)) + self.controls_state = state + except (OSError, ValueError, TypeError): + pass def open_chooser(self, payload): try: @@ -705,6 +762,10 @@ class Helper: try: if page.evaluate("typeof SteamClient === 'object' && typeof SteamClient.WebUITransport === 'object'") is not True: raise LookupError("SteamClient is not ready") + if os.path.isfile(os.path.join(CONTROLS_DIR, "state.json")): + page.call("Runtime.addBinding", {"name": BRIGHTNESS_BINDING}) + page.evaluate(BRIGHTNESS_JS) + self.controls_state = None if self.files_only: page.call("Runtime.addBinding", {"name": FILE_BINDING}) page.evaluate(FILE_JS) @@ -854,6 +915,8 @@ class Helper: say("preparing SteamVR for library app(s): " + ", ".join(sorted(vr_games))) self.vr_launch = launch_steamvr() for e in events: + if called(e, BRIGHTNESS_BINDING): + brightness_request(e.get("params", {}).get("payload")) if called(e, FILE_BINDING) and isinstance(e.get("params", {}).get("payload"), str): self.open_chooser(e["params"]["payload"]) return events @@ -861,15 +924,14 @@ class Helper: def serve_files(self): say("attached to the client on port %d for its file dialogs" % self.port) while True: + self.sync_controls() sources = [self.page.ws] + ([self.chooser[1].stdout] if self.chooser is not None else []) queued = self.page.ws.pending() or bool(self.page.events) - ready = [self.page.ws] if queued else select.select(sources, [], [], 30)[0] + ready = [self.page.ws] if queued else select.select(sources, [], [], 0.25)[0] if self.chooser is not None and self.chooser[1].stdout in ready: self.chooser_done() if self.page.ws in ready or self.page.events: - for e in self.page.drain(): - if called(e, FILE_BINDING) and isinstance(e.get("params", {}).get("payload"), str): - self.open_chooser(e["params"]["payload"]) + self.drain() def serve(self, watcher): if self.files_only: @@ -880,10 +942,11 @@ class Helper: self.reconcile() self.ensure_tools() while True: + self.sync_controls() sources = [self.page.ws] + ([watcher] if watcher.fileno() >= 0 else []) if self.chooser is not None: sources.append(self.chooser[1].stdout) - ready = [self.page.ws] if self.page.ws.pending() else select.select(sources, [], [], 30 if watcher.fileno() >= 0 else 2)[0] + ready = [self.page.ws] if self.page.ws.pending() else select.select(sources, [], [], 0.25)[0] if self.chooser is not None and self.chooser[1].stdout in ready: self.chooser_done() due = False diff --git a/tools/tests/test_device_controls.py b/tools/tests/test_device_controls.py new file mode 100644 index 0000000000..3a513a89fa --- /dev/null +++ b/tools/tests/test_device_controls.py @@ -0,0 +1,82 @@ +import json +from pathlib import Path +import runpy +import subprocess +import tempfile +import unittest + +BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin" +LIVE = runpy.run_path(str(BIN / "droiddeck-steam-compat")) + + +class DeviceControlsTest(unittest.TestCase): + def test_native_brightness_notifications_do_not_echo_android_readback(self): + harness = r""" +const assert = require('assert'); +globalThis.window = globalThis; +const requests = [], callbacks = []; +let current = 1; +window.droiddeckBrightnessChanged = value => requests.push(Number(value)); +globalThis.SteamClient = { System: { Display: { + RegisterForBrightnessChanges(cb) { callbacks.push(cb); cb({ flBrightness: 1 }); return {}; }, + SetBrightness(value) { + if (current === value) return; + current = value; + callbacks.forEach(cb => cb({ flBrightness: value })); + } +} } }; +const script = require('fs').readFileSync(process.argv[2], 'utf8'); +assert.strictEqual(eval(script), 'installed'); +assert.strictEqual(eval(script), 'present'); +const bridge = window.__droiddeckBrightness; +bridge.set(0.5); +bridge.set(0.5); +assert.deepStrictEqual(requests, []); +callbacks.forEach(cb => cb({ flBrightness: 0.8 })); +assert.deepStrictEqual(requests, [0.8]); +bridge.set(0.7992126); +assert.deepStrictEqual(requests, [0.8]); +for (const value of [NaN, Infinity, -1, 2, '0.5']) callbacks.forEach(cb => cb({ flBrightness: value })); +assert.deepStrictEqual(requests, [0.8]); +assert.strictEqual(callbacks.length, 1); +""" + with tempfile.TemporaryDirectory() as directory: + script = Path(directory) / "bridge.js" + script.write_text(LIVE["BRIGHTNESS_JS"]) + test = Path(directory) / "test.js" + test.write_text(harness) + result = subprocess.run(["node", str(test), str(script)], capture_output=True, text=True, timeout=20) + self.assertEqual(result.returncode, 0, result.stderr) + + def test_requests_reject_nonfinite_and_out_of_range_values(self): + with tempfile.TemporaryDirectory() as directory: + path = Path(directory) / "brightness.request" + for value in ["NaN", "Infinity", "-0.1", "1.1", "invalid", None]: + LIVE["brightness_request"](value, directory) + self.assertFalse(path.exists()) + LIVE["brightness_request"]("0.4", directory) + self.assertEqual(float(path.read_text()), 0.4) + + def test_failed_request_revision_republishes_the_actual_brightness(self): + with tempfile.TemporaryDirectory() as directory: + globals_ = LIVE["Helper"].sync_controls.__globals__ + previous = globals_["CONTROLS_DIR"] + try: + globals_["CONTROLS_DIR"] = directory + helper = LIVE["Helper"]("/steam", 0) + calls = [] + helper.page = type("Page", (), {"evaluate": lambda self, expression: calls.append(expression)})() + path = Path(directory) / "state.json" + path.write_text(json.dumps({"brightness": 0.5, "revision": 1})) + helper.sync_controls() + helper.sync_controls() + self.assertEqual(len(calls), 1) + path.write_text(json.dumps({"brightness": 0.5, "revision": 2})) + helper.sync_controls() + self.assertEqual(len(calls), 2) + finally: + globals_["CONTROLS_DIR"] = previous + + +if __name__ == "__main__": + unittest.main() From 53d643dd005b5c4477087fd5cf22e95f9fb9288f Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Mon, 26 Oct 2026 12:34:31 -0400 Subject: [PATCH 2/6] fix(audio): clear volume bridge during sink teardown --- tools/aaudio-sink/module-aaudio-sink.c | 1 + tools/directaudio/sink/module-directaudio-native-sink.c | 1 + 2 files changed, 2 insertions(+) diff --git a/tools/aaudio-sink/module-aaudio-sink.c b/tools/aaudio-sink/module-aaudio-sink.c index 3c129ce4b6..e79a20a54a 100644 --- a/tools/aaudio-sink/module-aaudio-sink.c +++ b/tools/aaudio-sink/module-aaudio-sink.c @@ -508,6 +508,7 @@ void pa__done(pa_module *m) { return; android_volume_free(u->android_volume); + u->android_volume = NULL; if (u->sink) pa_sink_unlink(u->sink); if (u->thread) { diff --git a/tools/directaudio/sink/module-directaudio-native-sink.c b/tools/directaudio/sink/module-directaudio-native-sink.c index 4d03e6bd4d..3b6e5f6c9c 100644 --- a/tools/directaudio/sink/module-directaudio-native-sink.c +++ b/tools/directaudio/sink/module-directaudio-native-sink.c @@ -809,6 +809,7 @@ void pa__done(pa_module *m) { if (!(u = m->userdata)) return; android_volume_free(u->android_volume); + u->android_volume = NULL; if (u->sink) pa_sink_unlink(u->sink); if (u->thread) { From dde1a55d00a6bb8964018efc1e0db42048740e05 Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Mon, 26 Oct 2026 12:49:51 -0400 Subject: [PATCH 3/6] feat(input): pass held Back through as Steam QAM --- .../com/droiddeck/launcher/SessionActivity.kt | 15 +++ .../droiddeck/launcher/input/BackQamInput.kt | 42 +++++++ .../droiddeck/launcher/input/PadBridge.java | 17 ++- .../launcher/ui/ModeSettingsDialog.kt | 4 +- .../droiddeck/launcher/ui/SessionOverlay.kt | 4 +- app/src/main/res/values/strings.xml | 1 + .../launcher/input/BackQamInputTest.kt | 90 ++++++++++++++ .../launcher/input/PadBridgeQamTest.kt | 115 ++++++++++++++++++ 8 files changed, 285 insertions(+), 3 deletions(-) create mode 100644 app/src/main/java/com/droiddeck/launcher/input/BackQamInput.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/input/BackQamInputTest.kt create mode 100644 app/src/test/java/com/droiddeck/launcher/input/PadBridgeQamTest.kt diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index b9dce0e415..7599185ff3 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -257,6 +257,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private val cursorResync = Runnable { if (syncClientCursor() && clientHidesCursor) cursorVisible = false } private val uiHandler = Handler(Looper.getMainLooper()) private var pendingBackAction: Runnable? = null + private val backQamInput = com.droiddeck.launcher.input.BackQamInput { padBridge?.setBackQamPressed(it) } private var drawerDirectionKey = KeyEvent.KEYCODE_UNKNOWN private var drawerDirectionDownTime = 0L private var drawerDirectionDeviceId = -1 @@ -446,6 +447,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } override fun onInputDeviceRemoved(deviceId: Int) { Log.i(TAG, "input device $deviceId disconnected") + backQamInput.onDeviceRemoved(deviceId) joyConVr?.refresh() padBridge?.onDeviceRemoved(deviceId) if (::padMouse.isInitialized) padMouse.reset() @@ -773,6 +775,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } LaunchedEffect(drawerOpen, pcKeyboardOpen, achievementsOpen, gestureSettingsOpen, pipUi, SessionState.suspended) { if (drawerOpen || pcKeyboardOpen || achievementsOpen || gestureSettingsOpen || pipUi || SessionState.suspended) { + backQamInput.cancel() cancelTouchGestures() screenKeys?.stopEditing() } @@ -2106,6 +2109,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } private fun releasePads() { + backQamInput.cancel() padBridge?.releaseAll() joyConVr?.releaseButtons() } @@ -2184,6 +2188,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { KeyEvent.KEYCODE_VOLUME_UP, KeyEvent.KEYCODE_VOLUME_DOWN, KeyEvent.KEYCODE_VOLUME_MUTE -> return super.dispatchKeyEvent(event) } + val backToQam = !pipUi && !screenKeyTextFocus && !drawerOpen && !pcKeyboardOpen && !achievementsOpen && + SessionState.mode == SessionService.MODE_STEAM && SessionState.running && SessionState.firstFrameSeen && + !SessionState.suspended && padBridge?.canHoldQam() == true + if (backQamInput.onKeyEvent(event, backToQam)) { + pendingBackAction?.let(uiHandler::removeCallbacks) + pendingBackAction = null + return true + } if (pipUi) return true if (screenKeyTextFocus) return super.dispatchKeyEvent(event) val pad = com.droiddeck.launcher.input.JoyCon.normalize(event) @@ -3253,6 +3265,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { override fun onPause() { if (runtimeRemovalBlocked) { super.onPause(); return } + backQamInput.cancel() capturePausedFrame() sessionClipboard.stop() if (::touchscreenGestures.isInitialized) touchscreenGestures.cancel() @@ -3636,6 +3649,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { override fun onWindowFocusChanged(hasFocus: Boolean) { super.onWindowFocusChanged(hasFocus) + if (!hasFocus) backQamInput.cancel() if (!hasFocus && ::padMouse.isInitialized) padMouse.reset() if (runtimeRemovalBlocked) return if (!hasFocus) { @@ -3683,6 +3697,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } override fun onDestroy() { + backQamInput.cancel() steamVrRecovery.close() uiHandler.removeCallbacks(steamTouchRetry) if (runtimeRemovalBlocked) { super.onDestroy(); return } diff --git a/app/src/main/java/com/droiddeck/launcher/input/BackQamInput.kt b/app/src/main/java/com/droiddeck/launcher/input/BackQamInput.kt new file mode 100644 index 0000000000..4ba4e3391d --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/input/BackQamInput.kt @@ -0,0 +1,42 @@ +package com.droiddeck.launcher.input + +import android.view.KeyEvent + +class BackQamInput(private val setPressed: (Boolean) -> Unit) { + private val held = mutableSetOf() + private val cancelled = mutableSetOf() + + fun onKeyEvent(event: KeyEvent, enabled: Boolean): Boolean { + if (!enabled) cancel() + if (event.keyCode != KeyEvent.KEYCODE_BACK) return false + val device = event.deviceId + return when (event.action) { + KeyEvent.ACTION_DOWN -> { + if (event.repeatCount > 0) return enabled || device in held || device in cancelled + cancelled.remove(device) + if (!enabled || event.isCanceled) return false + if (held.add(device) && held.size == 1) setPressed(true) + true + } + KeyEvent.ACTION_UP -> { + val released = held.remove(device) + val wasCancelled = cancelled.remove(device) + if (released && held.isEmpty()) setPressed(false) + released || wasCancelled || enabled + } + else -> device in held || device in cancelled + } + } + + fun cancel() { + if (held.isEmpty()) return + cancelled.addAll(held) + held.clear() + setPressed(false) + } + + fun onDeviceRemoved(device: Int) { + cancelled.remove(device) + if (held.remove(device) && held.isEmpty()) setPressed(false) + } +} 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 0811cab05e..2ed8037afd 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/PadBridge.java +++ b/app/src/main/java/com/droiddeck/launcher/input/PadBridge.java @@ -61,6 +61,7 @@ public final class PadBridge { private final PadState routedTouch = new PadState(); private boolean systemGuidePressed; private boolean systemQamPressed; + private boolean backQamPressed; private boolean qamChordActive; private int chordButton = -1; private boolean chordButtonPressed; @@ -132,6 +133,7 @@ public final class PadBridge { routedTouch.clear(); systemGuidePressed = false; systemQamPressed = false; + backQamPressed = false; qamTapPressed = false; qamChordActive = false; chordButtonPressed = false; @@ -165,6 +167,7 @@ public final class PadBridge { } systemGuidePressed = false; systemQamPressed = false; + backQamPressed = false; qamChordActive = false; chordButtonPressed = false; qamTapPressed = false; @@ -459,6 +462,7 @@ public final class PadBridge { public synchronized void releaseAll() { routedTouch.clear(); + backQamPressed = false; releaseBackPaddles(); state.clear(); publish(); @@ -479,6 +483,17 @@ public final class PadBridge { return SessionState.getDeckPad() && FakeInputWriter.padHasQam(); } + public boolean canHoldQam() { + return builtinPad && nativeQam(); + } + + public synchronized void setBackQamPressed(boolean pressed) { + if (pressed && !canHoldQam()) return; + if (backQamPressed == pressed) return; + backQamPressed = pressed; + publish(); + } + public synchronized void triggerQam() { if (!builtinPad) return; if (!nativeQam()) { @@ -684,7 +699,7 @@ public final class PadBridge { return; } boolean guide = systemGuidePressed || qamChordActive; - boolean qam = nativeQam() && (systemQamPressed || qamTapPressed); + boolean qam = nativeQam() && (systemQamPressed || qamTapPressed || backQamPressed); if (!guide && !qam) { writer.writePad(state); return; 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 86c03309f8..78fc3b00cb 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt @@ -306,7 +306,9 @@ fun ModeSheetRows(s: ModeSettings, a: ModeSettingsActions, tab: String, extras: stringResource(R.string.unfolded_controls_with_controller_hint), s.unfoldedControlsWithController, onChange = a.onUnfoldedControlsWithController, ) - if (steam) ChoiceRow( + if (steam && s.steamController in listOf(SessionPrefs.CONTROLLER_DECK, SessionPrefs.CONTROLLER_STEAM)) { + Note(stringResource(R.string.back_native_qam_hint)) + } else if (steam) ChoiceRow( host, "back-actions", stringResource(R.string.mode_back), stringResource(SessionPrefs.backActionsOrder(s.backActionsInverted)), listOf( false to stringResource(SessionPrefs.BACK_MENU_THEN_QAM), 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 b526bea285..bed8cccbd6 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt @@ -604,7 +604,9 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont chipModifier = focus.track(page, "keyboard-button"), onChange = a.onKeyboardButton) } } - if (a.steam) ChoiceRow(host, "back-actions", stringResource(R.string.mode_back), null, + if (a.steam && a.padType in listOf(SessionPrefs.CONTROLLER_DECK, SessionPrefs.CONTROLLER_STEAM)) { + Note(stringResource(R.string.back_native_qam_hint)) + } else if (a.steam) ChoiceRow(host, "back-actions", stringResource(R.string.mode_back), null, listOf(false to stringResource(SessionPrefs.BACK_MENU_THEN_QAM), true to stringResource(SessionPrefs.BACK_QAM_THEN_MENU)), a.backActionsInverted, chipModifier = focus.track(page, "back-actions"), onPick = a.onBackActionsInverted) if (a.steam && a.unfoldedControls != null) ToggleRow(host, "unfolded-controls", stringResource(R.string.unfolded_controls), diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 6b598b8c25..6cf0674c2d 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -306,6 +306,7 @@ Xbox 360 controller Deck: Quick Access button and gyro. Steam Controller: the same, with grip sense on the back buttons. DualShock 4 and DualSense: gyro, and the trackpads as their touchpad. Xbox 360: open Quick Access with Guide+A. Back + Back acts as Quick Access. Hold it with another button for Steam shortcuts. Menu → QAM QAM → Menu Session diff --git a/app/src/test/java/com/droiddeck/launcher/input/BackQamInputTest.kt b/app/src/test/java/com/droiddeck/launcher/input/BackQamInputTest.kt new file mode 100644 index 0000000000..37a7abda0d --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/input/BackQamInputTest.kt @@ -0,0 +1,90 @@ +package com.droiddeck.launcher.input + +import android.view.KeyEvent +import org.junit.Assert.* +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34], manifest = Config.NONE) +class BackQamInputTest { + private val changes = mutableListOf() + private val input = BackQamInput(changes::add) + + @Test fun aHoldAndItsRepeatsProduceOnePressAndOneRelease() { + assertTrue(send(KeyEvent.ACTION_DOWN)) + for (repeat in 1..10) assertTrue(send(KeyEvent.ACTION_DOWN, repeat = repeat)) + assertEquals(listOf(true), changes) + assertTrue(send(KeyEvent.ACTION_UP)) + assertEquals(listOf(true, false), changes) + } + + @Test fun otherButtonsAndSelectPassThroughWhileBackIsHeld() { + send(KeyEvent.ACTION_DOWN) + for (code in listOf(KeyEvent.KEYCODE_BUTTON_X, KeyEvent.KEYCODE_BUTTON_SELECT)) { + for (action in listOf(KeyEvent.ACTION_DOWN, KeyEvent.ACTION_UP)) { + assertFalse(input.onKeyEvent(KeyEvent(action, code), true)) + } + } + assertEquals(listOf(true), changes) + send(KeyEvent.ACTION_UP) + assertEquals(listOf(true, false), changes) + } + + @Test fun disabledRoutingPreservesBackNavigation() { + assertFalse(send(KeyEvent.ACTION_DOWN, enabled = false)) + assertFalse(send(KeyEvent.ACTION_UP, enabled = false)) + assertTrue(changes.isEmpty()) + } + + @Test fun losingFocusReleasesQamAndConsumesTheLateRelease() { + send(KeyEvent.ACTION_DOWN) + input.cancel() + input.cancel() + assertTrue(send(KeyEvent.ACTION_DOWN, repeat = 1, enabled = false)) + assertTrue(send(KeyEvent.ACTION_UP, enabled = false)) + assertEquals(listOf(true, false), changes) + assertFalse(send(KeyEvent.ACTION_UP, enabled = false)) + } + + @Test fun openingAnOverlayReleasesQamBeforeRoutingItsNextKey() { + send(KeyEvent.ACTION_DOWN) + assertFalse(input.onKeyEvent(KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BUTTON_B), false)) + assertTrue(send(KeyEvent.ACTION_UP, enabled = false)) + assertEquals(listOf(true, false), changes) + } + + @Test fun repeatsAfterCancellationCannotReassertQam() { + send(KeyEvent.ACTION_DOWN) + input.cancel() + assertTrue(send(KeyEvent.ACTION_DOWN, repeat = 1)) + assertEquals(listOf(true, false), changes) + assertTrue(send(KeyEvent.ACTION_DOWN)) + assertTrue(send(KeyEvent.ACTION_UP)) + assertEquals(listOf(true, false, true, false), changes) + } + + @Test fun cancelledReleaseStillReleasesQam() { + send(KeyEvent.ACTION_DOWN) + assertTrue(input.onKeyEvent(KeyEvent(0, 100, KeyEvent.ACTION_UP, KeyEvent.KEYCODE_BACK, + 0, 0, 4, 0, KeyEvent.FLAG_CANCELED), true)) + assertEquals(listOf(true, false), changes) + } + + @Test fun removingOneDeviceDoesNotReleaseAnotherDevicesHold() { + send(KeyEvent.ACTION_DOWN, device = 4) + send(KeyEvent.ACTION_DOWN, device = 5) + input.onDeviceRemoved(4) + assertTrue(changes.last()) + send(KeyEvent.ACTION_UP, device = 5) + assertFalse(changes.last()) + send(KeyEvent.ACTION_DOWN, device = 4) + input.onDeviceRemoved(4) + assertFalse(changes.last()) + } + + private fun send(action: Int, repeat: Int = 0, device: Int = 4, enabled: Boolean = true) = + input.onKeyEvent(KeyEvent(0, 100, action, KeyEvent.KEYCODE_BACK, repeat, 0, device, 0), enabled) +} diff --git a/app/src/test/java/com/droiddeck/launcher/input/PadBridgeQamTest.kt b/app/src/test/java/com/droiddeck/launcher/input/PadBridgeQamTest.kt new file mode 100644 index 0000000000..3491076a24 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/input/PadBridgeQamTest.kt @@ -0,0 +1,115 @@ +package com.droiddeck.launcher.input + +import android.os.Handler +import com.droiddeck.launcher.session.SessionState +import java.nio.file.Files +import java.time.Duration +import org.junit.After +import org.junit.Assert.* +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config +import org.robolectric.util.ReflectionHelpers + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34], manifest = Config.NONE, instrumentedPackages = ["com.droiddeck.launcher.input.FakeInputWriter"], + shadows = [JoyConPadTest.RecordingWriter::class]) +class PadBridgeQamTest { + private val directory = Files.createTempDirectory("qam-pad").toFile() + private lateinit var bridge: PadBridge + + @Before fun start() { + JoyConPadTest.RecordingWriter.pads.clear() + ReflectionHelpers.setStaticField(FakeInputWriter::class.java, "padType", FakeInputWriter.PAD_TYPE_DECK) + SessionState.deckPad = true + bridge = PadBridge(directory) + assertTrue(bridge.start()) + } + + @After fun stop() { + bridge.stop() + SessionState.deckPad = false + directory.deleteRecursively() + } + + @Test fun onlyNativeQamControllersAcceptAHeldBack() { + for (type in listOf(-1, FakeInputWriter.PAD_TYPE_DECK, FakeInputWriter.PAD_TYPE_STEAM, + FakeInputWriter.PAD_TYPE_XBOX, FakeInputWriter.PAD_TYPE_DS4, FakeInputWriter.PAD_TYPE_DUALSENSE)) { + ReflectionHelpers.setStaticField(FakeInputWriter::class.java, "padType", type) + val supported = type <= FakeInputWriter.PAD_TYPE_STEAM + assertEquals(supported, bridge.canHoldQam()) + bridge.setBackQamPressed(true) + bridge.applyExternal({}, false) + assertEquals(supported, pad().isDown(PadState.QAM)) + bridge.setBackQamPressed(false) + } + SessionState.deckPad = false + assertFalse(bridge.canHoldQam()) + } + + @Test fun qamAndOtherButtonsShareAReportUntilBackIsReleased() { + bridge.setBackQamPressed(true) + advanceTime() + bridge.applyExternal({ it.press(PadState.X, true); it.press(PadState.SELECT, true) }, true) + assertTrue(pad().isDown(PadState.QAM)) + assertTrue(pad().isDown(PadState.X)) + assertTrue(pad().isDown(PadState.SELECT)) + bridge.setBackQamPressed(false) + assertFalse(pad().isDown(PadState.QAM)) + assertTrue(pad().isDown(PadState.X)) + assertTrue(pad().isDown(PadState.SELECT)) + } + + @Test fun touchQamAndBackHaveIndependentReleases() { + bridge.setBackQamPressed(true) + bridge.setSystemButtons(false, true) + bridge.setBackQamPressed(false) + assertTrue(pad().isDown(PadState.QAM)) + bridge.setBackQamPressed(true) + bridge.setSystemButtons(false, false) + assertTrue(pad().isDown(PadState.QAM)) + bridge.setBackQamPressed(false) + assertFalse(pad().isDown(PadState.QAM)) + } + + @Test fun aTimedQamTapCannotReleaseAHeldBack() { + bridge.triggerQam() + bridge.setBackQamPressed(true) + advanceTime() + assertTrue(pad().isDown(PadState.QAM)) + bridge.setBackQamPressed(false) + assertFalse(pad().isDown(PadState.QAM)) + } + + @Test fun releasingAllOrStoppingClearsTheHold() { + bridge.setBackQamPressed(true) + bridge.releaseAll() + assertFalse(pad().isDown(PadState.QAM)) + bridge.setBackQamPressed(true) + bridge.stop() + bridge.start() + bridge.applyExternal({}, false) + assertFalse(pad().isDown(PadState.QAM)) + } + + @Test fun disablingTheBuiltinPadClearsAndRejectsTheHold() { + bridge.setBackQamPressed(true) + bridge.setBuiltinPad(false) + assertFalse(bridge.canHoldQam()) + assertFalse(pad().isDown(PadState.QAM)) + bridge.setBackQamPressed(true) + bridge.setBuiltinPad(true) + bridge.applyExternal({}, false) + assertFalse(pad().isDown(PadState.QAM)) + } + + private fun pad() = requireNotNull(JoyConPadTest.RecordingWriter.pads[0]) + + private fun advanceTime() { + val handler = ReflectionHelpers.getStaticField(PadBridge::class.java, "chordHandler") + shadowOf(handler.looper).idleFor(Duration.ofSeconds(2)) + } +} From fa5506df35a7fa3ac00e7e82fc0cc7fcecbba9bd Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Mon, 26 Oct 2026 13:13:08 -0400 Subject: [PATCH 4/6] fix(steam): preserve Back taps and recover QAM controls --- .../com/droiddeck/launcher/SessionActivity.kt | 5 +- .../droiddeck/launcher/input/BackQamInput.kt | 60 ++++++++--- .../runtime/DeviceControlsComponent.kt | 34 ++++-- .../launcher/session/SessionService.kt | 2 +- .../launcher/ui/ModeSettingsDialog.kt | 7 +- .../droiddeck/launcher/ui/SessionOverlay.kt | 7 +- app/src/main/res/values/strings.xml | 4 +- .../launcher/input/BackQamInputTest.kt | 96 +++++++++++++++-- .../runtime/DeviceControlsComponentTest.kt | 35 +++++- tools/aaudio-sink/android-volume.h | 17 ++- .../usr/local/bin/droiddeck-steam-compat | 29 +++-- tools/tests/test_android_volume.py | 101 ++++++++++++++++++ tools/tests/test_device_controls.py | 54 +++++++++- 13 files changed, 395 insertions(+), 56 deletions(-) create mode 100644 tools/tests/test_android_volume.py diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index 7599185ff3..f4bb0b6e2f 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -257,7 +257,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private val cursorResync = Runnable { if (syncClientCursor() && clientHidesCursor) cursorVisible = false } private val uiHandler = Handler(Looper.getMainLooper()) private var pendingBackAction: Runnable? = null - private val backQamInput = com.droiddeck.launcher.input.BackQamInput { padBridge?.setBackQamPressed(it) } + private val backQamInput = com.droiddeck.launcher.input.BackQamInput( + setPressed = { padBridge?.setBackQamPressed(it) }, + onTap = { performBackAction(double = it) }, + ) private var drawerDirectionKey = KeyEvent.KEYCODE_UNKNOWN private var drawerDirectionDownTime = 0L private var drawerDirectionDeviceId = -1 diff --git a/app/src/main/java/com/droiddeck/launcher/input/BackQamInput.kt b/app/src/main/java/com/droiddeck/launcher/input/BackQamInput.kt index 4ba4e3391d..ef8042aa67 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/BackQamInput.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/BackQamInput.kt @@ -1,10 +1,21 @@ package com.droiddeck.launcher.input import android.view.KeyEvent +import android.os.Handler +import android.os.Looper -class BackQamInput(private val setPressed: (Boolean) -> Unit) { - private val held = mutableSetOf() +class BackQamInput(private val setPressed: (Boolean) -> Unit, private val onTap: (Boolean) -> Unit) { + private class Press(val hold: Runnable, var held: Boolean = false, var used: Boolean = false) + private val handler = Handler(Looper.getMainLooper()) + private val presses = mutableMapOf() private val cancelled = mutableSetOf() + private var tapPending = false + private val singleTap = Runnable { tapPending = false; onTap(false) } + + private fun cancelTap() { + handler.removeCallbacks(singleTap) + tapPending = false + } fun onKeyEvent(event: KeyEvent, enabled: Boolean): Boolean { if (!enabled) cancel() @@ -12,31 +23,54 @@ class BackQamInput(private val setPressed: (Boolean) -> Unit) { val device = event.deviceId return when (event.action) { KeyEvent.ACTION_DOWN -> { - if (event.repeatCount > 0) return enabled || device in held || device in cancelled + if (event.repeatCount > 0) return enabled || device in presses || device in cancelled cancelled.remove(device) if (!enabled || event.isCanceled) return false - if (held.add(device) && held.size == 1) setPressed(true) + if (device in presses) return true + handler.removeCallbacks(singleTap) + val hold = Runnable { + val press = presses[device] ?: return@Runnable + val alreadyHeld = presses.values.any { it.held } + press.held = true + presses.values.forEach { it.used = true } + cancelTap() + if (!alreadyHeld) setPressed(true) + } + presses[device] = Press(hold, used = presses.values.any { it.held }) + handler.postDelayed(hold, 500) true } KeyEvent.ACTION_UP -> { - val released = held.remove(device) + val press = presses.remove(device) val wasCancelled = cancelled.remove(device) - if (released && held.isEmpty()) setPressed(false) - released || wasCancelled || enabled + if (press != null) { + handler.removeCallbacks(press.hold) + if (press.held && presses.values.none { it.held }) setPressed(false) + if (!press.used && !event.isCanceled) { + if (tapPending) { cancelTap(); onTap(true) } + else { tapPending = true; handler.postDelayed(singleTap, 500) } + } else if (event.isCanceled) cancelTap() + } + press != null || wasCancelled || enabled } - else -> device in held || device in cancelled + else -> device in presses || device in cancelled } } fun cancel() { - if (held.isEmpty()) return - cancelled.addAll(held) - held.clear() - setPressed(false) + cancelTap() + val wasHeld = presses.values.any { it.held } + presses.values.forEach { handler.removeCallbacks(it.hold) } + cancelled.addAll(presses.keys) + presses.clear() + if (wasHeld) setPressed(false) } fun onDeviceRemoved(device: Int) { cancelled.remove(device) - if (held.remove(device) && held.isEmpty()) setPressed(false) + val press = presses.remove(device) ?: return + handler.removeCallbacks(press.hold) + cancelTap() + if (press.held && presses.values.none { it.held }) setPressed(false) } } diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/DeviceControlsComponent.kt b/app/src/main/java/com/droiddeck/launcher/runtime/DeviceControlsComponent.kt index c88666dfb5..3e0eaf8b21 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/DeviceControlsComponent.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/DeviceControlsComponent.kt @@ -2,6 +2,10 @@ package com.droiddeck.launcher.runtime import android.content.Context import android.content.Intent +import android.app.Notification +import android.app.NotificationChannel +import android.app.NotificationManager +import android.app.PendingIntent import android.database.ContentObserver import android.media.AudioManager import android.net.Uri @@ -12,19 +16,20 @@ import android.os.SystemClock import android.provider.Settings import android.util.Log import com.droiddeck.launcher.core.SessionPart +import com.droiddeck.launcher.R import java.io.File import java.nio.file.Files import java.nio.file.StandardCopyOption import org.json.JSONObject import kotlin.math.roundToInt -class DeviceControlsComponent(context: Context, root: File) : SessionPart() { +class DeviceControlsComponent(context: Context, root: File, private val activityVisible: () -> Boolean = { false }) : SessionPart() { private val context = context.applicationContext private val audio = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager private val directory = directory(root) private val handler = Handler(Looper.getMainLooper()) private var running = false - private var pendingBrightness: Pair? = null + private var pendingBrightness: Float? = null private var permissionRequestAt = -5_000L private var previous = "" private var revision = 0L @@ -41,10 +46,10 @@ class DeviceControlsComponent(context: Context, root: File) : SessionPart() { override fun run() { if (!running) return consume() - pendingBrightness?.let { (value, time) -> - if (SystemClock.elapsedRealtime() - time > 120_000) pendingBrightness = null - else if (Settings.System.canWrite(context)) { + pendingBrightness?.let { value -> + if (Settings.System.canWrite(context)) { pendingBrightness = null + context.getSystemService(NotificationManager::class.java).cancel(PERMISSION_NOTIFICATION) brightness(value) } } @@ -94,6 +99,7 @@ class DeviceControlsComponent(context: Context, root: File) : SessionPart() { requests.stopWatching() context.contentResolver.unregisterContentObserver(observer) pendingBrightness = null + context.getSystemService(NotificationManager::class.java).cancel(PERMISSION_NOTIFICATION) } } @@ -128,13 +134,23 @@ class DeviceControlsComponent(context: Context, root: File) : SessionPart() { private fun brightness(value: Float) { if (!Settings.System.canWrite(context)) { - pendingBrightness = value to SystemClock.elapsedRealtime() + pendingBrightness = value val now = SystemClock.elapsedRealtime() if (now - permissionRequestAt >= 5_000) { permissionRequestAt = now try { - context.startActivity(Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS, - Uri.parse("package:${context.packageName}")).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)) + val intent = Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS, + Uri.parse("package:${context.packageName}")).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) + val manager = context.getSystemService(NotificationManager::class.java) + manager.createNotificationChannel(NotificationChannel(PERMISSION_CHANNEL, + context.getString(R.string.brightness_permission_title), NotificationManager.IMPORTANCE_DEFAULT)) + val action = PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_IMMUTABLE) + manager.notify(PERMISSION_NOTIFICATION, Notification.Builder(context, PERMISSION_CHANNEL) + .setSmallIcon(R.drawable.ic_stat_session) + .setContentTitle(context.getString(R.string.brightness_permission_title)) + .setContentText(context.getString(R.string.brightness_permission_text)) + .setContentIntent(action).setOnlyAlertOnce(true).setAutoCancel(true).build()) + if (activityVisible()) context.startActivity(intent) } catch (e: Exception) { Log.w(TAG, "Could not open brightness permission", e) } @@ -161,6 +177,8 @@ class DeviceControlsComponent(context: Context, root: File) : SessionPart() { companion object { private const val TAG = "DeviceControls" + private const val PERMISSION_CHANNEL = "brightness_permission" + private const val PERMISSION_NOTIFICATION = 0x4442 private val REQUESTS = setOf("brightness.request", "volume.request", "mute.request") @JvmStatic fun directory(root: File) = File(root, "etc/droiddeck-device-controls") @JvmStatic fun prepareBacklight(context: Context, root: File): File { 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 252f94103f..c5b5f8415c 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -630,7 +630,7 @@ class SessionService : Service() { networkLink.attach(this) networkLink.publish() components.add(networkLink) - val deviceControls = com.droiddeck.launcher.runtime.DeviceControlsComponent(this, root) + val deviceControls = com.droiddeck.launcher.runtime.DeviceControlsComponent(this, root) { activityVisible && screenOn } deviceControls.attach(this) deviceControls.publish() components.add(deviceControls) 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 78fc3b00cb..598995cd92 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt @@ -306,15 +306,16 @@ fun ModeSheetRows(s: ModeSettings, a: ModeSettingsActions, tab: String, extras: stringResource(R.string.unfolded_controls_with_controller_hint), s.unfoldedControlsWithController, onChange = a.onUnfoldedControlsWithController, ) - if (steam && s.steamController in listOf(SessionPrefs.CONTROLLER_DECK, SessionPrefs.CONTROLLER_STEAM)) { - Note(stringResource(R.string.back_native_qam_hint)) - } else if (steam) ChoiceRow( + if (steam) ChoiceRow( host, "back-actions", stringResource(R.string.mode_back), stringResource(SessionPrefs.backActionsOrder(s.backActionsInverted)), listOf( false to stringResource(SessionPrefs.BACK_MENU_THEN_QAM), true to stringResource(SessionPrefs.BACK_QAM_THEN_MENU), ), s.backActionsInverted, onPick = a.onBackActionsInverted, ) + if (steam && s.steamController in listOf(SessionPrefs.CONTROLLER_DECK, SessionPrefs.CONTROLLER_STEAM)) { + Note(stringResource(R.string.back_native_qam_hint)) + } } } if (tab == SheetTab.AUDIO && steam) { 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 bed8cccbd6..5ea179ea1c 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt @@ -604,11 +604,12 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont chipModifier = focus.track(page, "keyboard-button"), onChange = a.onKeyboardButton) } } - if (a.steam && a.padType in listOf(SessionPrefs.CONTROLLER_DECK, SessionPrefs.CONTROLLER_STEAM)) { - Note(stringResource(R.string.back_native_qam_hint)) - } else if (a.steam) ChoiceRow(host, "back-actions", stringResource(R.string.mode_back), null, + if (a.steam) ChoiceRow(host, "back-actions", stringResource(R.string.mode_back), null, listOf(false to stringResource(SessionPrefs.BACK_MENU_THEN_QAM), true to stringResource(SessionPrefs.BACK_QAM_THEN_MENU)), a.backActionsInverted, chipModifier = focus.track(page, "back-actions"), onPick = a.onBackActionsInverted) + if (a.steam && a.padType in listOf(SessionPrefs.CONTROLLER_DECK, SessionPrefs.CONTROLLER_STEAM)) { + Note(stringResource(R.string.back_native_qam_hint)) + } if (a.steam && a.unfoldedControls != null) ToggleRow(host, "unfolded-controls", stringResource(R.string.unfolded_controls), stringResource(R.string.unfolded_controls_hint), a.unfoldedControls, chipModifier = focus.track(page, "unfolded-controls"), onChange = a.onUnfoldedControls) diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 6cf0674c2d..0e600fceb0 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -306,7 +306,9 @@ Xbox 360 controller Deck: Quick Access button and gyro. Steam Controller: the same, with grip sense on the back buttons. DualShock 4 and DualSense: gyro, and the trackpads as their touchpad. Xbox 360: open Quick Access with Guide+A. Back - Back acts as Quick Access. Hold it with another button for Steam shortcuts. + Hold Back for 500 ms, then press another button for Steam shortcuts. Single and double taps keep the selected actions. + Allow brightness control + Tap to allow Steam to change Android screen brightness. Menu → QAM QAM → Menu Session diff --git a/app/src/test/java/com/droiddeck/launcher/input/BackQamInputTest.kt b/app/src/test/java/com/droiddeck/launcher/input/BackQamInputTest.kt index 37a7abda0d..3b3c459925 100644 --- a/app/src/test/java/com/droiddeck/launcher/input/BackQamInputTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/input/BackQamInputTest.kt @@ -1,28 +1,76 @@ package com.droiddeck.launcher.input +import android.os.Looper import android.view.KeyEvent +import java.time.Duration import org.junit.Assert.* import org.junit.Test import org.junit.runner.RunWith import org.robolectric.RobolectricTestRunner +import org.robolectric.Shadows.shadowOf import org.robolectric.annotation.Config @RunWith(RobolectricTestRunner::class) @Config(sdk = [34], manifest = Config.NONE) class BackQamInputTest { private val changes = mutableListOf() - private val input = BackQamInput(changes::add) + private val taps = mutableListOf() + private val input = BackQamInput(changes::add, taps::add) - @Test fun aHoldAndItsRepeatsProduceOnePressAndOneRelease() { + @Test fun singleTapWaitsForTheDoubleTapWindowWithoutPressingQam() { + send(KeyEvent.ACTION_DOWN) + advance(100) + send(KeyEvent.ACTION_UP) + advance(499) + assertTrue(taps.isEmpty()) + advance(1) + assertEquals(listOf(false), taps) + assertTrue(changes.isEmpty()) + } + + @Test fun doubleTapProducesOnlyTheDoubleAction() { + repeat(2) { + send(KeyEvent.ACTION_DOWN) + advance(100) + send(KeyEvent.ACTION_UP) + advance(100) + } + advance(1000) + assertEquals(listOf(true), taps) + assertTrue(changes.isEmpty()) + } + + @Test fun aHoldStartsAt500msAndNeverProducesATap() { assertTrue(send(KeyEvent.ACTION_DOWN)) + advance(499) + assertTrue(changes.isEmpty()) + advance(1) for (repeat in 1..10) assertTrue(send(KeyEvent.ACTION_DOWN, repeat = repeat)) + advance(4000) assertEquals(listOf(true), changes) assertTrue(send(KeyEvent.ACTION_UP)) + advance(1000) assertEquals(listOf(true, false), changes) + assertTrue(taps.isEmpty()) + } + + @Test fun holdingTheSecondPressCancelsTheFirstTap() { + send(KeyEvent.ACTION_DOWN) + send(KeyEvent.ACTION_UP) + advance(400) + send(KeyEvent.ACTION_DOWN) + advance(499) + assertTrue(taps.isEmpty()) + advance(1) + assertEquals(listOf(true), changes) + send(KeyEvent.ACTION_UP) + advance(1000) + assertTrue(taps.isEmpty()) } @Test fun otherButtonsAndSelectPassThroughWhileBackIsHeld() { send(KeyEvent.ACTION_DOWN) + advance(500) for (code in listOf(KeyEvent.KEYCODE_BUTTON_X, KeyEvent.KEYCODE_BUTTON_SELECT)) { for (action in listOf(KeyEvent.ACTION_DOWN, KeyEvent.ACTION_UP)) { assertFalse(input.onKeyEvent(KeyEvent(action, code), true)) @@ -37,20 +85,42 @@ class BackQamInputTest { assertFalse(send(KeyEvent.ACTION_DOWN, enabled = false)) assertFalse(send(KeyEvent.ACTION_UP, enabled = false)) assertTrue(changes.isEmpty()) + assertTrue(taps.isEmpty()) } @Test fun losingFocusReleasesQamAndConsumesTheLateRelease() { send(KeyEvent.ACTION_DOWN) + advance(500) input.cancel() input.cancel() assertTrue(send(KeyEvent.ACTION_DOWN, repeat = 1, enabled = false)) assertTrue(send(KeyEvent.ACTION_UP, enabled = false)) + advance(1000) assertEquals(listOf(true, false), changes) - assertFalse(send(KeyEvent.ACTION_UP, enabled = false)) + assertTrue(taps.isEmpty()) + } + + @Test fun cancellationBeforeTheThresholdPreventsBothHoldAndTap() { + send(KeyEvent.ACTION_DOWN) + advance(100) + input.cancel() + send(KeyEvent.ACTION_UP) + advance(1000) + assertTrue(changes.isEmpty()) + assertTrue(taps.isEmpty()) + } + + @Test fun cancellationAlsoDiscardsAPendingSingleTap() { + send(KeyEvent.ACTION_DOWN) + send(KeyEvent.ACTION_UP) + input.cancel() + advance(1000) + assertTrue(taps.isEmpty()) } @Test fun openingAnOverlayReleasesQamBeforeRoutingItsNextKey() { send(KeyEvent.ACTION_DOWN) + advance(500) assertFalse(input.onKeyEvent(KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BUTTON_B), false)) assertTrue(send(KeyEvent.ACTION_UP, enabled = false)) assertEquals(listOf(true, false), changes) @@ -58,33 +128,39 @@ class BackQamInputTest { @Test fun repeatsAfterCancellationCannotReassertQam() { send(KeyEvent.ACTION_DOWN) + advance(500) input.cancel() assertTrue(send(KeyEvent.ACTION_DOWN, repeat = 1)) + advance(1000) assertEquals(listOf(true, false), changes) assertTrue(send(KeyEvent.ACTION_DOWN)) + advance(500) assertTrue(send(KeyEvent.ACTION_UP)) assertEquals(listOf(true, false, true, false), changes) } - @Test fun cancelledReleaseStillReleasesQam() { + @Test fun cancelledReleaseNeverProducesATap() { send(KeyEvent.ACTION_DOWN) assertTrue(input.onKeyEvent(KeyEvent(0, 100, KeyEvent.ACTION_UP, KeyEvent.KEYCODE_BACK, 0, 0, 4, 0, KeyEvent.FLAG_CANCELED), true)) - assertEquals(listOf(true, false), changes) + advance(1000) + assertTrue(changes.isEmpty()) + assertTrue(taps.isEmpty()) } @Test fun removingOneDeviceDoesNotReleaseAnotherDevicesHold() { send(KeyEvent.ACTION_DOWN, device = 4) send(KeyEvent.ACTION_DOWN, device = 5) + advance(500) input.onDeviceRemoved(4) - assertTrue(changes.last()) + assertEquals(listOf(true), changes) send(KeyEvent.ACTION_UP, device = 5) - assertFalse(changes.last()) - send(KeyEvent.ACTION_DOWN, device = 4) - input.onDeviceRemoved(4) - assertFalse(changes.last()) + assertEquals(listOf(true, false), changes) + assertTrue(taps.isEmpty()) } + private fun advance(millis: Long) = shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(millis)) + private fun send(action: Int, repeat: Int = 0, device: Int = 4, enabled: Boolean = true) = input.onKeyEvent(KeyEvent(0, 100, action, KeyEvent.KEYCODE_BACK, repeat, 0, device, 0), enabled) } diff --git a/app/src/test/java/com/droiddeck/launcher/runtime/DeviceControlsComponentTest.kt b/app/src/test/java/com/droiddeck/launcher/runtime/DeviceControlsComponentTest.kt index 9e0da30aa7..fa96dacc99 100644 --- a/app/src/test/java/com/droiddeck/launcher/runtime/DeviceControlsComponentTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/runtime/DeviceControlsComponentTest.kt @@ -1,6 +1,7 @@ package com.droiddeck.launcher.runtime import android.app.Application +import android.app.NotificationManager import android.content.Context import android.media.AudioManager import android.os.Looper @@ -24,20 +25,21 @@ import org.robolectric.annotation.Implementation import org.robolectric.shadows.ShadowSettings @RunWith(RobolectricTestRunner::class) -@Config(sdk = [28], manifest = Config.NONE, application = Application::class, shadows = [WriteSettingsShadow::class]) +@Config(sdk = [28, 33], manifest = Config.NONE, application = Application::class, shadows = [WriteSettingsShadow::class]) class DeviceControlsComponentTest { @get:Rule val tmp = TemporaryFolder() private val context get() = RuntimeEnvironment.getApplication() private val audio get() = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager private lateinit var component: DeviceControlsComponent private lateinit var directory: File + private var visible = true @Before fun start() { WriteSettingsShadow.writable = true Settings.System.putInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS, 128) val root = tmp.newFolder() directory = DeviceControlsComponent.directory(root) - component = DeviceControlsComponent(context, root) + component = DeviceControlsComponent(context, root) { visible } component.publish() component.start() shadowOf(Looper.getMainLooper()).idle() @@ -85,6 +87,35 @@ class DeviceControlsComponentTest { assertEquals(1.0, JSONObject(File(directory, "state.json").readText()).getDouble("brightness"), 0.0001) } + @Test fun hiddenPermissionRequestOffersANotificationAndRetainsTheLatestValue() { + visible = false + WriteSettingsShadow.writable = false + request("brightness", "0.25") + request("brightness", "0.75") + assertNull(shadowOf(context).nextStartedActivity) + val notifications = context.getSystemService(NotificationManager::class.java) + val notification = notifications.activeNotifications.single().notification + notification.contentIntent.send() + assertEquals(Settings.ACTION_MANAGE_WRITE_SETTINGS, shadowOf(context).nextStartedActivity.action) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(121)) + WriteSettingsShadow.writable = true + tick() + assertEquals(192, Settings.System.getInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS)) + assertTrue(notifications.activeNotifications.isEmpty()) + } + + @Test fun stoppingClearsThePermissionNotificationAndPendingRequest() { + visible = false + WriteSettingsShadow.writable = false + request("brightness", "0.75") + component.stop() + shadowOf(Looper.getMainLooper()).idle() + assertTrue(context.getSystemService(NotificationManager::class.java).activeNotifications.isEmpty()) + WriteSettingsShadow.writable = true + tick() + assertEquals(128, Settings.System.getInt(context.contentResolver, Settings.System.SCREEN_BRIGHTNESS)) + } + @Test fun stoppedSessionsDoNotConsumeNewCommands() { component.stop() shadowOf(Looper.getMainLooper()).idle() diff --git a/tools/aaudio-sink/android-volume.h b/tools/aaudio-sink/android-volume.h index b7f4ec9d18..6a31befeb1 100644 --- a/tools/aaudio-sink/android-volume.h +++ b/tools/aaudio-sink/android-volume.h @@ -1,6 +1,7 @@ /* SPDX-License-Identifier: LGPL-2.1-or-later */ #include #include +#include struct android_volume { pa_sink *sink; @@ -59,6 +60,10 @@ static void android_volume_refresh(pa_mainloop_api *api, pa_time_event *event, c access(processing, F_OK) != 0 && access(mute_processing, F_OK) != 0 && android_volume_read(bridge->directory, &level, &maximum, &muted)) { pa_cvolume volume; + if (bridge->sink->n_volume_steps != maximum + 1) { + bridge->sink->n_volume_steps = maximum + 1; + pa_subscription_post(bridge->sink->core, PA_SUBSCRIPTION_EVENT_SINK | PA_SUBSCRIPTION_EVENT_CHANGE, bridge->sink->index); + } pa_cvolume_set(&volume, bridge->sink->sample_spec.channels, (uint64_t)level * PA_VOLUME_NORM / maximum); if (!pa_cvolume_equal(&volume, &bridge->sink->real_volume)) pa_sink_volume_changed(bridge->sink, &volume); if (bridge->sink->muted != !!muted) pa_sink_mute_changed(bridge->sink, !!muted); @@ -72,14 +77,16 @@ static void android_volume_refresh(pa_mainloop_api *api, pa_time_event *event, c static struct android_volume *android_volume_new(pa_sink *sink, const char *directory) { unsigned level, maximum, muted; - if (!directory || !android_volume_read(directory, &level, &maximum, &muted)) return NULL; + if (!directory) return NULL; struct android_volume *bridge = pa_xnew0(struct android_volume, 1); bridge->sink = sink; bridge->directory = pa_xstrdup(directory); - pa_cvolume_set(&sink->real_volume, sink->sample_spec.channels, (uint64_t)level * PA_VOLUME_NORM / maximum); - sink->reference_volume = sink->real_volume; - sink->muted = !!muted; - sink->n_volume_steps = maximum + 1; + if (android_volume_read(directory, &level, &maximum, &muted)) { + pa_cvolume_set(&sink->real_volume, sink->sample_spec.channels, (uint64_t)level * PA_VOLUME_NORM / maximum); + sink->reference_volume = sink->real_volume; + sink->muted = !!muted; + sink->n_volume_steps = maximum + 1; + } pa_cvolume_reset(&sink->soft_volume, sink->sample_spec.channels); pa_sink_set_set_volume_callback(sink, android_volume_set); pa_sink_set_set_mute_callback(sink, android_volume_mute); diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat index 595563019b..4c46216c22 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat @@ -23,19 +23,21 @@ BRIGHTNESS_JS = r""" if (window.__droiddeckBrightness) return "present"; const display = SteamClient.System?.Display; if (!display?.RegisterForBrightnessChanges || !display?.SetBrightness) return "unavailable"; - const self = { expected: null, updating: true }; + const self = { expected: null, updating: true, revision: 0 }; self.set = value => { if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) return; if (!self.updating && self.expected !== null && Math.abs(value - self.expected) < 0.0001) return; self.expected = value; self.updating = true; + const revision = ++self.revision; + setTimeout(() => { if (self.revision === revision) self.updating = false; }, 500); display.SetBrightness(value); }; self.subscription = display.RegisterForBrightnessChanges(state => { const value = state?.flBrightness; if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1 || self.expected === null) return; if (Math.abs(value - self.expected) < 0.0001) { self.updating = false; return; } - if (self.updating) return; + if (self.updating) { self.updating = false; return; } self.expected = value; if (typeof window.__BINDING__ === "function") window.__BINDING__(String(value)); }); @@ -677,6 +679,7 @@ class Helper: self.vr_launch = None self.chooser = None self.controls_state = None + self.controls_installed = False def sync_controls(self): try: @@ -685,9 +688,17 @@ class Helper: value = state.get("brightness") if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value) or not 0 <= value <= 1: return + if not self.controls_installed: + self.page.call("Runtime.addBinding", {"name": BRIGHTNESS_BINDING}) + self.controls_installed = self.page.evaluate(BRIGHTNESS_JS) in ("installed", "present") + if not self.controls_installed: + return if state != self.controls_state: - self.page.evaluate("window.__droiddeckBrightness?.set(%s)" % json.dumps(value)) - self.controls_state = state + if self.page.evaluate("!!window.__droiddeckBrightness && (window.__droiddeckBrightness.set(%s), true)" % json.dumps(value)) is True: + self.controls_state = state + else: + self.controls_installed = False + self.controls_state = None except (OSError, ValueError, TypeError): pass @@ -762,14 +773,13 @@ class Helper: try: if page.evaluate("typeof SteamClient === 'object' && typeof SteamClient.WebUITransport === 'object'") is not True: raise LookupError("SteamClient is not ready") - if os.path.isfile(os.path.join(CONTROLS_DIR, "state.json")): - page.call("Runtime.addBinding", {"name": BRIGHTNESS_BINDING}) - page.evaluate(BRIGHTNESS_JS) - self.controls_state = None if self.files_only: page.call("Runtime.addBinding", {"name": FILE_BINDING}) page.evaluate(FILE_JS) self.page = page + self.controls_state = None + self.controls_installed = False + self.sync_controls() return True page.call("Runtime.addBinding", {"name": BINDING}) page.call("Runtime.addBinding", {"name": VR_BINDING}) @@ -789,6 +799,9 @@ class Helper: page.ws.close() raise self.page = page + self.controls_state = None + self.controls_installed = False + self.sync_controls() return True def reconcile(self): diff --git a/tools/tests/test_android_volume.py b/tools/tests/test_android_volume.py new file mode 100644 index 0000000000..8246f34fe1 --- /dev/null +++ b/tools/tests/test_android_volume.py @@ -0,0 +1,101 @@ +from pathlib import Path +import shutil +import subprocess +import tempfile +import unittest + + +@unittest.skipUnless(shutil.which("cc"), "C compiler required") +class AndroidVolumeTest(unittest.TestCase): + def test_missing_or_invalid_initial_state_recovers_without_restarting_the_sink(self): + header = Path(__file__).resolve().parents[1] / "aaudio-sink/android-volume.h" + harness = r''' +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define PA_VOLUME_NORM 65536U +#define PA_USEC_PER_MSEC 1000 +#define PA_SINK_INIT 0 +#define PA_SUBSCRIPTION_EVENT_SINK 1 +#define PA_SUBSCRIPTION_EVENT_CHANGE 2 +#define PA_MIN(a,b) ((a)<(b)?(a):(b)) +#define pa_xnew0(type,n) ((type*)calloc(n,sizeof(type))) +#define pa_xstrdup strdup +#define pa_xfree free +#define pa_log_warn(...) ((void)0) +typedef struct { unsigned value; } pa_cvolume; +typedef struct pa_time_event { int value; } pa_time_event; +typedef struct pa_mainloop_api { void (*time_free)(pa_time_event*); } pa_mainloop_api; +typedef struct { pa_mainloop_api *mainloop; } pa_core; +typedef struct pa_sink { + void *userdata; int state; bool muted; unsigned n_volume_steps, index; + struct { unsigned channels; } sample_spec; + pa_cvolume real_volume, reference_volume, soft_volume; + pa_core *core; + void (*set_volume)(struct pa_sink*), (*set_mute)(struct pa_sink*); +} pa_sink; +struct android_volume; +struct userdata { struct android_volume *android_volume; }; +static int restarts, frees; +static char *pa_sprintf_malloc(const char *format, ...) { + va_list ap; va_start(ap,format); char *result; assert(vasprintf(&result,format,ap)>=0); va_end(ap); return result; +} +static void pa_cvolume_set(pa_cvolume *volume, unsigned channels, unsigned value) { volume->value=value; } +static unsigned pa_cvolume_max(const pa_cvolume *volume) { return volume->value; } +static void pa_cvolume_reset(pa_cvolume *volume, unsigned channels) { volume->value=PA_VOLUME_NORM; } +static bool pa_cvolume_equal(const pa_cvolume *a, const pa_cvolume *b) { return a->value==b->value; } +static void pa_sink_volume_changed(pa_sink *sink, const pa_cvolume *volume) { sink->real_volume=*volume; } +static void pa_sink_mute_changed(pa_sink *sink, bool muted) { sink->muted=muted; } +static void pa_sink_set_set_volume_callback(pa_sink *sink, void (*callback)(pa_sink*)) { sink->set_volume=callback; } +static void pa_sink_set_set_mute_callback(pa_sink *sink, void (*callback)(pa_sink*)) { sink->set_mute=callback; } +static void pa_subscription_post(pa_core *core, int event, unsigned index) {} +static uint64_t pa_rtclock_now(void) { return 0; } +static void pa_core_rttime_restart(pa_core *core, pa_time_event *event, uint64_t time) { restarts++; } +static pa_time_event *pa_core_rttime_new(pa_core *core, uint64_t time, + void (*callback)(pa_mainloop_api*,pa_time_event*,const struct timeval*,void*), void *userdata) { + return calloc(1,sizeof(pa_time_event)); +} +static void free_timer(pa_time_event *event) { frees++; free(event); } +#include "android-volume.h" +static void state(const char *directory, const char *text) { + char *path=pa_sprintf_malloc("%s/volume.state",directory); + FILE *f=fopen(path,"w"); assert(f); fputs(text,f); fclose(f); free(path); +} +int main(int argc, char **argv) { + pa_mainloop_api api={.time_free=free_timer}; pa_core core={.mainloop=&api}; + struct userdata userdata={0}; + pa_sink sink={.userdata=&userdata,.core=&core,.state=1,.sample_spec={.channels=2},.real_volume={PA_VOLUME_NORM}}; + userdata.android_volume=android_volume_new(&sink,argv[1]); + assert(userdata.android_volume && userdata.android_volume->timer && sink.set_volume && sink.set_mute); + state(argv[1],"invalid\n"); + android_volume_refresh(&api,userdata.android_volume->timer,NULL,userdata.android_volume); + assert(sink.real_volume.value==PA_VOLUME_NORM && restarts==1); + state(argv[1],"3 15 1\n"); + android_volume_refresh(&api,userdata.android_volume->timer,NULL,userdata.android_volume); + assert(sink.real_volume.value==3*PA_VOLUME_NORM/15 && sink.muted && sink.n_volume_steps==16); + assert(sink.soft_volume.value==PA_VOLUME_NORM && restarts==2); + sink.real_volume.value=2*PA_VOLUME_NORM/3; sink.set_volume(&sink); + char *request=pa_sprintf_malloc("%s/volume.request",argv[1]); + FILE *f=fopen(request,"r"); unsigned level; assert(f && fscanf(f,"%u",&level)==1 && level==10); fclose(f); free(request); + android_volume_free(userdata.android_volume); assert(frees==1); + return 0; +} +''' + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + (root / "pulsecore").mkdir() + for name in ("core-rtclock.h", "core-subscribe.h"): + (root / "pulsecore" / name).touch() + source = root / "test.c" + source.write_text(harness) + binary = root / "test" + subprocess.run(["cc", "-std=c11", "-I", str(root), "-I", str(header.parent), + str(source), "-o", str(binary)], check=True, capture_output=True) + subprocess.run([str(binary), str(root)], check=True, capture_output=True) diff --git a/tools/tests/test_device_controls.py b/tools/tests/test_device_controls.py index 3a513a89fa..9f914c5d38 100644 --- a/tools/tests/test_device_controls.py +++ b/tools/tests/test_device_controls.py @@ -15,6 +15,8 @@ class DeviceControlsTest(unittest.TestCase): const assert = require('assert'); globalThis.window = globalThis; const requests = [], callbacks = []; +const timers = []; +globalThis.setTimeout = callback => timers.push(callback); let current = 1; window.droiddeckBrightnessChanged = value => requests.push(Number(value)); globalThis.SteamClient = { System: { Display: { @@ -39,6 +41,16 @@ assert.deepStrictEqual(requests, [0.8]); for (const value of [NaN, Infinity, -1, 2, '0.5']) callbacks.forEach(cb => cb({ flBrightness: value })); assert.deepStrictEqual(requests, [0.8]); assert.strictEqual(callbacks.length, 1); +SteamClient.System.Display.SetBrightness = value => callbacks.forEach(cb => cb({ flBrightness: value + 0.1 })); +bridge.set(0.3); +assert.deepStrictEqual(requests, [0.8]); +callbacks.forEach(cb => cb({ flBrightness: 0.6 })); +assert.deepStrictEqual(requests, [0.8, 0.6]); +SteamClient.System.Display.SetBrightness = () => {}; +bridge.set(0.65); +timers.forEach(callback => callback()); +callbacks.forEach(cb => cb({ flBrightness: 0.7 })); +assert.deepStrictEqual(requests, [0.8, 0.6, 0.7]); """ with tempfile.TemporaryDirectory() as directory: script = Path(directory) / "bridge.js" @@ -65,7 +77,8 @@ assert.strictEqual(callbacks.length, 1); globals_["CONTROLS_DIR"] = directory helper = LIVE["Helper"]("/steam", 0) calls = [] - helper.page = type("Page", (), {"evaluate": lambda self, expression: calls.append(expression)})() + helper.controls_installed = True + helper.page = type("Page", (), {"evaluate": lambda self, expression: calls.append(expression) or True})() path = Path(directory) / "state.json" path.write_text(json.dumps({"brightness": 0.5, "revision": 1})) helper.sync_controls() @@ -77,6 +90,45 @@ assert.strictEqual(callbacks.length, 1); finally: globals_["CONTROLS_DIR"] = previous + def test_display_bridge_retries_binding_and_install_before_caching_state(self): + with tempfile.TemporaryDirectory() as directory: + globals_ = LIVE["Helper"].sync_controls.__globals__ + previous = globals_["CONTROLS_DIR"] + try: + globals_["CONTROLS_DIR"] = directory + Path(directory, "state.json").write_text(json.dumps({"brightness": 0.5, "revision": 1})) + calls, installs, writes = [], ["unavailable", "installed", "present"], [] + class Page: + present = True + def call(self, method, params): + calls.append((method, params)) + def evaluate(self, expression): + if expression == LIVE["BRIGHTNESS_JS"]: + return installs.pop(0) + writes.append(expression) + return self.present + helper = LIVE["Helper"]("/steam", 0) + helper.page = Page() + helper.sync_controls() + self.assertIsNone(helper.controls_state) + self.assertFalse(writes) + helper.sync_controls() + helper.sync_controls() + self.assertEqual(len(calls), 2) + self.assertEqual(len(writes), 1) + self.assertEqual(calls[1], ("Runtime.addBinding", {"name": LIVE["BRIGHTNESS_BINDING"]})) + helper.page.present = False + Path(directory, "state.json").write_text(json.dumps({"brightness": 0.7, "revision": 2})) + helper.sync_controls() + self.assertIsNone(helper.controls_state) + self.assertFalse(helper.controls_installed) + helper.page.present = True + helper.sync_controls() + self.assertEqual(len(calls), 3) + self.assertEqual(helper.controls_state["brightness"], 0.7) + finally: + globals_["CONTROLS_DIR"] = previous + if __name__ == "__main__": unittest.main() From 749ade4a45018b47bf50d9e8ef932e5895aebb20 Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Mon, 26 Oct 2026 13:20:51 -0400 Subject: [PATCH 5/6] fix(input): delay held QAM to 700 ms --- .../droiddeck/launcher/input/BackQamInput.kt | 2 +- .../droiddeck/launcher/ui/SessionOverlay.kt | 3 --- app/src/main/res/values/strings.xml | 2 +- .../launcher/input/BackQamInputTest.kt | 27 ++++++++++++------- 4 files changed, 20 insertions(+), 14 deletions(-) diff --git a/app/src/main/java/com/droiddeck/launcher/input/BackQamInput.kt b/app/src/main/java/com/droiddeck/launcher/input/BackQamInput.kt index ef8042aa67..83e1adafbf 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/BackQamInput.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/BackQamInput.kt @@ -37,7 +37,7 @@ class BackQamInput(private val setPressed: (Boolean) -> Unit, private val onTap: if (!alreadyHeld) setPressed(true) } presses[device] = Press(hold, used = presses.values.any { it.held }) - handler.postDelayed(hold, 500) + handler.postDelayed(hold, 700) true } KeyEvent.ACTION_UP -> { 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 5ea179ea1c..b526bea285 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt @@ -607,9 +607,6 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont if (a.steam) ChoiceRow(host, "back-actions", stringResource(R.string.mode_back), null, listOf(false to stringResource(SessionPrefs.BACK_MENU_THEN_QAM), true to stringResource(SessionPrefs.BACK_QAM_THEN_MENU)), a.backActionsInverted, chipModifier = focus.track(page, "back-actions"), onPick = a.onBackActionsInverted) - if (a.steam && a.padType in listOf(SessionPrefs.CONTROLLER_DECK, SessionPrefs.CONTROLLER_STEAM)) { - Note(stringResource(R.string.back_native_qam_hint)) - } if (a.steam && a.unfoldedControls != null) ToggleRow(host, "unfolded-controls", stringResource(R.string.unfolded_controls), stringResource(R.string.unfolded_controls_hint), a.unfoldedControls, chipModifier = focus.track(page, "unfolded-controls"), onChange = a.onUnfoldedControls) diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 0e600fceb0..840e26ebb6 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -306,7 +306,7 @@ Xbox 360 controller Deck: Quick Access button and gyro. Steam Controller: the same, with grip sense on the back buttons. DualShock 4 and DualSense: gyro, and the trackpads as their touchpad. Xbox 360: open Quick Access with Guide+A. Back - Hold Back for 500 ms, then press another button for Steam shortcuts. Single and double taps keep the selected actions. + Hold Back for 700 ms, then press another button for Steam shortcuts. Single and double taps keep the selected actions. Allow brightness control Tap to allow Steam to change Android screen brightness. Menu → QAM diff --git a/app/src/test/java/com/droiddeck/launcher/input/BackQamInputTest.kt b/app/src/test/java/com/droiddeck/launcher/input/BackQamInputTest.kt index 3b3c459925..8006a495b2 100644 --- a/app/src/test/java/com/droiddeck/launcher/input/BackQamInputTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/input/BackQamInputTest.kt @@ -40,9 +40,9 @@ class BackQamInputTest { assertTrue(changes.isEmpty()) } - @Test fun aHoldStartsAt500msAndNeverProducesATap() { + @Test fun aHoldStartsAt700msAndNeverProducesATap() { assertTrue(send(KeyEvent.ACTION_DOWN)) - advance(499) + advance(699) assertTrue(changes.isEmpty()) advance(1) for (repeat in 1..10) assertTrue(send(KeyEvent.ACTION_DOWN, repeat = repeat)) @@ -54,12 +54,21 @@ class BackQamInputTest { assertTrue(taps.isEmpty()) } + @Test fun releasingBetween500And700msStillProducesASingleTap() { + send(KeyEvent.ACTION_DOWN) + advance(600) + send(KeyEvent.ACTION_UP) + advance(500) + assertEquals(listOf(false), taps) + assertTrue(changes.isEmpty()) + } + @Test fun holdingTheSecondPressCancelsTheFirstTap() { send(KeyEvent.ACTION_DOWN) send(KeyEvent.ACTION_UP) advance(400) send(KeyEvent.ACTION_DOWN) - advance(499) + advance(699) assertTrue(taps.isEmpty()) advance(1) assertEquals(listOf(true), changes) @@ -70,7 +79,7 @@ class BackQamInputTest { @Test fun otherButtonsAndSelectPassThroughWhileBackIsHeld() { send(KeyEvent.ACTION_DOWN) - advance(500) + advance(700) for (code in listOf(KeyEvent.KEYCODE_BUTTON_X, KeyEvent.KEYCODE_BUTTON_SELECT)) { for (action in listOf(KeyEvent.ACTION_DOWN, KeyEvent.ACTION_UP)) { assertFalse(input.onKeyEvent(KeyEvent(action, code), true)) @@ -90,7 +99,7 @@ class BackQamInputTest { @Test fun losingFocusReleasesQamAndConsumesTheLateRelease() { send(KeyEvent.ACTION_DOWN) - advance(500) + advance(700) input.cancel() input.cancel() assertTrue(send(KeyEvent.ACTION_DOWN, repeat = 1, enabled = false)) @@ -120,7 +129,7 @@ class BackQamInputTest { @Test fun openingAnOverlayReleasesQamBeforeRoutingItsNextKey() { send(KeyEvent.ACTION_DOWN) - advance(500) + advance(700) assertFalse(input.onKeyEvent(KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BUTTON_B), false)) assertTrue(send(KeyEvent.ACTION_UP, enabled = false)) assertEquals(listOf(true, false), changes) @@ -128,13 +137,13 @@ class BackQamInputTest { @Test fun repeatsAfterCancellationCannotReassertQam() { send(KeyEvent.ACTION_DOWN) - advance(500) + advance(700) input.cancel() assertTrue(send(KeyEvent.ACTION_DOWN, repeat = 1)) advance(1000) assertEquals(listOf(true, false), changes) assertTrue(send(KeyEvent.ACTION_DOWN)) - advance(500) + advance(700) assertTrue(send(KeyEvent.ACTION_UP)) assertEquals(listOf(true, false, true, false), changes) } @@ -151,7 +160,7 @@ class BackQamInputTest { @Test fun removingOneDeviceDoesNotReleaseAnotherDevicesHold() { send(KeyEvent.ACTION_DOWN, device = 4) send(KeyEvent.ACTION_DOWN, device = 5) - advance(500) + advance(700) input.onDeviceRemoved(4) assertEquals(listOf(true), changes) send(KeyEvent.ACTION_UP, device = 5) From 4d7ceb2325a0fec6e72458bba60398e94bbd1d9a Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Mon, 26 Oct 2026 13:27:03 -0400 Subject: [PATCH 6/6] fix(steam): drain queued control notifications --- .../usr/local/bin/droiddeck-steam-compat | 3 +- tools/tests/test_device_controls.py | 37 +++++++++++++++++++ 2 files changed, 39 insertions(+), 1 deletion(-) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat index 4c46216c22..126afe0505 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat @@ -959,7 +959,8 @@ class Helper: sources = [self.page.ws] + ([watcher] if watcher.fileno() >= 0 else []) if self.chooser is not None: sources.append(self.chooser[1].stdout) - ready = [self.page.ws] if self.page.ws.pending() else select.select(sources, [], [], 0.25)[0] + queued = self.page.ws.pending() or bool(self.page.events) + ready = [self.page.ws] if queued else select.select(sources, [], [], 0.25)[0] if self.chooser is not None and self.chooser[1].stdout in ready: self.chooser_done() due = False diff --git a/tools/tests/test_device_controls.py b/tools/tests/test_device_controls.py index 9f914c5d38..091d29a5a5 100644 --- a/tools/tests/test_device_controls.py +++ b/tools/tests/test_device_controls.py @@ -4,12 +4,49 @@ import runpy import subprocess import tempfile import unittest +from unittest import mock BIN = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin" LIVE = runpy.run_path(str(BIN / "droiddeck-steam-compat")) class DeviceControlsTest(unittest.TestCase): + def test_sync_controls_queued_notifications_are_processed_without_another_frame(self): + with tempfile.TemporaryDirectory() as directory: + Path(directory, "state.json").write_text(json.dumps({"brightness": 0.5, "revision": 1})) + helper = LIVE["Helper"]("/steam", 0) + helper.controls_installed = True + page = mock.Mock(events=[]) + page.ws.pending.return_value = False + helper.page = page + payload = json.dumps({"id": 1, "options": {"strTitle": "Pick a file"}}) + def evaluate(expression): + for name, value in [(LIVE["BRIGHTNESS_BINDING"], "0.4"), (LIVE["FILE_BINDING"], payload)]: + page.events.append({"method": "Runtime.bindingCalled", "params": {"name": name, "payload": value}}) + return True + def drain(): + events, page.events = page.events, [] + return events + page.evaluate.side_effect = evaluate + page.drain.side_effect = drain + helper.reconcile = mock.Mock() + helper.ensure_tools = mock.Mock(side_effect=[None, StopIteration]) + helper.open_chooser = mock.Mock() + watcher = mock.Mock() + watcher.fileno.return_value = -1 + watcher.changed.return_value = False + globals_ = LIVE["Helper"].serve.__globals__ + with mock.patch.dict(globals_, {"CONTROLS_DIR": directory, + "brightness_request": lambda value: LIVE["brightness_request"](value, directory)}), \ + mock.patch.dict(globals_["COMPAT"], {"state_path": lambda name: str(Path(directory, name))}), \ + mock.patch.object(globals_["select"], "select", return_value=([], [], [])) as select_: + with self.assertRaises(StopIteration): + helper.serve(watcher) + self.assertEqual(float(Path(directory, "brightness.request").read_text()), 0.4) + helper.open_chooser.assert_called_once_with(payload) + self.assertEqual(page.events, []) + select_.assert_not_called() + def test_native_brightness_notifications_do_not_echo_android_readback(self): harness = r""" const assert = require('assert');