From 8121a2e07e209afd0910f5125c51040b1ac7eb04 Mon Sep 17 00:00:00 2001 From: xXJsonDeruloXx Date: Fri, 2 Oct 2026 16:05:47 -0400 Subject: [PATCH] Add optional Wi-Fi discovery permission flow in Steam settings --- app/src/main/AndroidManifest.xml | 2 +- .../com/droiddeck/launcher/MainActivity.kt | 65 +++++++++++++++++++ .../droiddeck/launcher/core/WifiDiscovery.kt | 24 +++++++ .../runtime/LinuxNetworkLinkComponent.kt | 31 +++++---- .../launcher/session/SessionPrefs.kt | 13 ++++ .../launcher/ui/ModeSettingsDialog.kt | 41 ++++++++++++ app/src/main/res/values/strings.xml | 9 +++ 7 files changed, 170 insertions(+), 15 deletions(-) create mode 100644 app/src/main/java/com/droiddeck/launcher/core/WifiDiscovery.kt diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 27c3dc0e39..6575350cd1 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -13,7 +13,7 @@ download from being throttled to nothing by the radio's power-save. --> - + diff --git a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt index e270a33441..af023ca792 100644 --- a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt @@ -47,6 +47,7 @@ import com.droiddeck.launcher.core.CpuCores import com.droiddeck.launcher.core.PhantomProcessLimit import com.droiddeck.launcher.core.PhantomProcessStatus import com.droiddeck.launcher.core.WirelessAdbFix +import com.droiddeck.launcher.core.WifiDiscovery import com.droiddeck.launcher.core.WirelessAdbPairingService import com.droiddeck.launcher.ui.CoreRow import com.droiddeck.launcher.ui.PerformancePage @@ -149,6 +150,24 @@ class MainActivity : ComponentActivity() { private var launcherFullscreen by mutableStateOf(true) private var storeEnabled by mutableStateOf(false) private var mic by mutableStateOf(false) + private var wifiDiscovery by mutableStateOf(false) + private var wifiDiscoveryPermission by mutableStateOf(false) + private var wifiDiscoveryLocation by mutableStateOf(false) + private var wifiDiscoveryAsked by mutableStateOf(false) + private var wifiDiscoveryBlocked by mutableStateOf(false) + private val wifiLocationReceiver = object : android.content.BroadcastReceiver() { + override fun onReceive(context: android.content.Context?, intent: Intent?) { + refreshWifiDiscovery() + } + } + private val wifiLocationPermission = registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { + SessionPrefs.setWifiDiscoveryEnabled(this, WifiDiscovery.permissionGranted(this)) + refreshWifiDiscovery() + } + private val wifiPermissionSettings = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { + SessionPrefs.setWifiDiscoveryEnabled(this, WifiDiscovery.permissionGranted(this)) + refreshWifiDiscovery() + } // The app's own picker (files/), once per kind of pick: the two driver lists validate // differently, and the reason a zip is refused names the list it belongs in. @@ -176,6 +195,28 @@ class MainActivity : ComponentActivity() { if (r.resultCode == RESULT_OK) InAppFilePicker.pickedFile(r.data)?.let(then) } + private fun refreshWifiDiscovery() { + wifiDiscoveryPermission = WifiDiscovery.permissionGranted(this) + wifiDiscoveryLocation = WifiDiscovery.locationEnabled(this) + wifiDiscoveryAsked = SessionPrefs.wifiDiscoveryAsked(this) + wifiDiscoveryBlocked = !wifiDiscoveryPermission && wifiDiscoveryAsked && + WifiDiscovery.permissions.none { shouldShowRequestPermissionRationale(it) } + // A revoked grant must not leave an enabled switch behind. + if (!wifiDiscoveryPermission && SessionPrefs.wifiDiscoveryEnabled(this)) { + SessionPrefs.setWifiDiscoveryEnabled(this, false) + } + wifiDiscovery = SessionPrefs.wifiDiscoveryEnabled(this) + } + + private fun openWifiDiscoverySettings() { + if (!WifiDiscovery.permissionGranted(this)) { + wifiPermissionSettings.launch(Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS, + Uri.parse("package:$packageName"))) + } else { + startActivity(Intent(android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS)) + } + } + /** Takes a new or updated Lossless Scaling from Steam and shows what LSFG can use. */ private fun syncLossless() { Thread({ @@ -680,6 +721,7 @@ class MainActivity : ComponentActivity() { override fun onResume() { super.onResume() + refreshWifiDiscovery() com.droiddeck.launcher.ui.Motion.refresh(this) // Back from a session stopped behind a flood: open on its blue, before the first frame. com.droiddeck.launcher.ui.QuitFlood.take()?.let { c -> @@ -717,6 +759,7 @@ class MainActivity : ComponentActivity() { override fun onStart() { super.onStart() + registerReceiver(wifiLocationReceiver, android.content.IntentFilter(android.location.LocationManager.MODE_CHANGED_ACTION)) displayManager.registerDisplayListener(secondScreenDisplayListener, ui) refreshSecondScreenDisplays() } @@ -727,6 +770,7 @@ class MainActivity : ComponentActivity() { } override fun onStop() { + unregisterReceiver(wifiLocationReceiver) displayManager.unregisterDisplayListener(secondScreenDisplayListener) // The session covers the page by now; coming back finds it as it was. flood = null @@ -963,6 +1007,11 @@ class MainActivity : ComponentActivity() { mangoapp = mangoapp, steamController = if (mode == SessionService.MODE_STEAM) steamController else null, runSteamAtStartup = mode == SessionService.MODE_STEAM && runSteamAtStartup, + wifiDiscovery = if (mode == SessionService.MODE_STEAM) wifiDiscovery else null, + wifiDiscoveryPermission = wifiDiscoveryPermission, + wifiDiscoveryLocation = wifiDiscoveryLocation, + wifiDiscoveryAsked = wifiDiscoveryAsked, + wifiDiscoveryBlocked = wifiDiscoveryBlocked, addedGamesDirs = if (mode == SessionService.MODE_STEAM) addedGamesDirs else null, addedGames = if (mode == SessionService.MODE_STEAM) addedGames else emptyList(), addedGamesArt = addedGamesArt, @@ -972,6 +1021,21 @@ class MainActivity : ComponentActivity() { deckyEnabled = decky.deckySupervisor, deckySessionRunning = SessionState.running, ), ModeSettingsActions( + onWifiDiscovery = { on -> + if (!on) { + SessionPrefs.setWifiDiscoveryEnabled(this, false) + refreshWifiDiscovery() + } else if (WifiDiscovery.permissionGranted(this)) { + SessionPrefs.setWifiDiscoveryEnabled(this, true) + refreshWifiDiscovery() + } else if (wifiDiscoveryBlocked) { + openWifiDiscoverySettings() + } else { + SessionPrefs.setWifiDiscoveryAsked(this) + wifiLocationPermission.launch(WifiDiscovery.permissions) + } + }, + onWifiDiscoverySettings = { openWifiDiscoverySettings() }, onResolution = { cap -> SessionPrefs.setResolutionCap(this, mode, cap); resolutionCap = cap }, onCustomResolution = { size -> SessionPrefs.setCustomResolution(this, mode, size); customResolution = size }, onShape = { shape -> SessionPrefs.setShapeMode(this, shape); shapeMode = shape }, @@ -1126,6 +1190,7 @@ class MainActivity : ComponentActivity() { forceFullscreen = SessionPrefs.forceFullscreen(this) stretch16x9 = SessionPrefs.stretch16x9(this) mic = SessionPrefs.micEnabled(this) + refreshWifiDiscovery() renderer = SessionPrefs.desktopRenderer(this) gameStorage = SessionPrefs.gameStorage(this) settingsMode = mode diff --git a/app/src/main/java/com/droiddeck/launcher/core/WifiDiscovery.kt b/app/src/main/java/com/droiddeck/launcher/core/WifiDiscovery.kt new file mode 100644 index 0000000000..40a6721dc5 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/core/WifiDiscovery.kt @@ -0,0 +1,24 @@ +package com.droiddeck.launcher.core + +import android.Manifest +import android.content.Context +import android.content.pm.PackageManager +import android.location.LocationManager +import android.os.Build +import com.droiddeck.launcher.session.SessionPrefs + +/** Location is used only for Android's Wi-Fi names and scan results, never coordinates. */ +object WifiDiscovery { + val permissions = arrayOf(Manifest.permission.ACCESS_COARSE_LOCATION, Manifest.permission.ACCESS_FINE_LOCATION) + + // targetSdk 28 accepts either grant for Wi-Fi scanning. + fun permissionGranted(context: Context): Boolean = permissions.any { + context.checkSelfPermission(it) == PackageManager.PERMISSION_GRANTED + } + + fun locationEnabled(context: Context): Boolean = Build.VERSION.SDK_INT < Build.VERSION_CODES.P || + (context.getSystemService(Context.LOCATION_SERVICE) as? LocationManager)?.isLocationEnabled == true + + fun available(context: Context): Boolean = SessionPrefs.wifiDiscoveryEnabled(context) && + permissionGranted(context) && locationEnabled(context) +} diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxNetworkLinkComponent.kt b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxNetworkLinkComponent.kt index 04ac1f9dc0..a47ca9330c 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxNetworkLinkComponent.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxNetworkLinkComponent.kt @@ -1,11 +1,9 @@ package com.droiddeck.launcher.runtime -import android.Manifest import android.content.BroadcastReceiver import android.content.Context import android.content.Intent import android.content.IntentFilter -import android.content.pm.PackageManager import android.location.LocationManager import android.net.ConnectivityManager import android.net.LinkProperties @@ -20,6 +18,7 @@ import android.os.SystemClock import android.provider.Settings import android.util.Log import com.droiddeck.launcher.core.SessionPart +import com.droiddeck.launcher.core.WifiDiscovery import java.io.File import java.io.IOException import java.net.Inet4Address @@ -56,8 +55,13 @@ class LinuxNetworkLinkComponent( private var wifiReceiver: BroadcastReceiver? = null private var scanRequestStamp = 0L private var lastScanRequest = -SCAN_INTERVAL_MS + @Volatile private var lastNamesAllowed = false private val scanRequests = object : Runnable { override fun run() { + if (canReadWifiNames() != lastNamesAllowed) { + synchronized(lock) { writeNetworkState(currentProperties, currentCapabilities) } + requestWifiScan() + } val stamp = File(rootDir, "etc/bannerlator-wifi-scan-request").lastModified() if (stamp != 0L && stamp != scanRequestStamp) { scanRequestStamp = stamp @@ -139,12 +143,7 @@ class LinuxNetworkLinkComponent( } } - private fun canReadWifiNames(): Boolean { - val allowed = listOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION) - .any { appContext.checkSelfPermission(it) == PackageManager.PERMISSION_GRANTED } - val location = appContext.getSystemService(Context.LOCATION_SERVICE) as? LocationManager - return allowed && (Build.VERSION.SDK_INT < Build.VERSION_CODES.P || location?.isLocationEnabled == true) - } + private fun canReadWifiNames(): Boolean = WifiDiscovery.available(appContext) @Suppress("DEPRECATION") private fun requestWifiScan() { @@ -179,6 +178,7 @@ class LinuxNetworkLinkComponent( @Suppress("DEPRECATION") private fun writeNetworkState(properties: LinkProperties?, capabilities: NetworkCapabilities?) { val namesAllowed = canReadWifiNames() + lastNamesAllowed = namesAllowed val scans = if (namesAllowed && wifiManager?.isWifiEnabled == true) { try { wifiManager.scanResults.orEmpty() } catch (e: SecurityException) { emptyList() } } else emptyList() @@ -231,18 +231,21 @@ class LinuxNetworkLinkComponent( } }) if (transport == "wifi") { + val connectionInfo = try { wifiManager?.connectionInfo } catch (e: SecurityException) { null } val info = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { - (capabilities?.transportInfo as? WifiInfo) ?: wifiManager?.connectionInfo + (capabilities?.transportInfo as? WifiInfo) ?: connectionInfo } else { - wifiManager?.connectionInfo + connectionInfo } if (info != null) { // SSIDs can be redacted by Android. No location permission is needed to // report the transport; a hidden name simply displays as Wi-Fi in Steam. - val namedInfo = if (namesAllowed) wifiManager?.connectionInfo ?: info else info - namedInfo.ssid?.takeUnless { it == WifiManager.UNKNOWN_SSID || it.isEmpty() } - ?.removeSurrounding("\"")?.let { put("ssid", it) } - namedInfo.bssid?.takeUnless { it == "02:00:00:00:00:00" }?.let { put("bssid", it) } + if (namesAllowed) { + val namedInfo = connectionInfo ?: info + namedInfo.ssid?.takeUnless { it == WifiManager.UNKNOWN_SSID || it.isEmpty() } + ?.removeSurrounding("\"")?.let { put("ssid", it) } + namedInfo.bssid?.takeUnless { it == "02:00:00:00:00:00" }?.let { put("bssid", it) } + } put("strength", WifiManager.calculateSignalLevel(info.rssi, 101)) put("frequency", info.frequency.coerceAtLeast(0)) put("bitrate", info.linkSpeed.coerceAtLeast(0) * 1000) diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index 9a6c12e09f..0bfe9c9d09 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -220,6 +220,19 @@ object SessionPrefs { prefs(context).edit().putBoolean("mic", on).apply() } + /** Optional SSID reporting and scans. A Location grant alone never opts the user in. */ + fun wifiDiscoveryEnabled(context: Context): Boolean = prefs(context).getBoolean("wifiDiscovery", false) + + fun setWifiDiscoveryEnabled(context: Context, on: Boolean) { + prefs(context).edit().putBoolean("wifiDiscovery", on).apply() + } + + fun wifiDiscoveryAsked(context: Context): Boolean = prefs(context).getBoolean("wifiDiscoveryAsked", false) + + fun setWifiDiscoveryAsked(context: Context) { + prefs(context).edit().putBoolean("wifiDiscoveryAsked", true).apply() + } + /** * Whether the client's own core pick is overridden. When on, BL_CLIENT_CPUS is sent even when * it names every core - unlike a game mask, the point here is to undo a pin Steam applies to 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 61f1e2fc0e..9d8a4009a0 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt @@ -80,6 +80,12 @@ class ModeSettings( val steamController: String? = null, /** Steam only: start a Steam session when DroidDeck opens. */ val runSteamAtStartup: Boolean = false, + /** Null outside Steam; the saved choice is separate from Android's access and device switch. */ + val wifiDiscovery: Boolean? = null, + val wifiDiscoveryPermission: Boolean = false, + val wifiDiscoveryLocation: Boolean = false, + val wifiDiscoveryAsked: Boolean = false, + val wifiDiscoveryBlocked: Boolean = false, /** Steam only: the user's chosen Games folders; null outside Steam. */ val addedGamesDirs: List? = null, val addedGames: List = emptyList(), @@ -125,6 +131,8 @@ class ModeSettingsActions( val onMangoapp: (Boolean) -> Unit = {}, val onSteamController: (String) -> Unit = {}, val onRunSteamAtStartup: (Boolean) -> Unit = {}, + val onWifiDiscovery: (Boolean) -> Unit = {}, + val onWifiDiscoverySettings: () -> Unit = {}, val onPickAddedGamesDir: () -> Unit = {}, val onForgetAddedGamesDir: (path: String) -> Unit = {}, val onAddedGamesArt: (Boolean) -> Unit = {}, @@ -142,6 +150,7 @@ fun ModeSettingsPage(s: ModeSettings, a: ModeSettingsActions) { val steam = s.mode == SessionService.MODE_STEAM val host = rememberMenuHost() var confirmDeckyRemoval by remember { mutableStateOf(false) } + var explainWifiDiscovery by remember { mutableStateOf(false) } val pageScroll = androidx.compose.foundation.rememberScrollState() val firstChip = remember { androidx.compose.ui.focus.FocusRequester() } androidx.compose.runtime.LaunchedEffect(Unit) { @@ -326,6 +335,25 @@ fun ModeSettingsPage(s: ModeSettings, a: ModeSettingsActions) { onPick = a.onSteamChannel, ) } + if (steam && s.wifiDiscovery != null) SettingsGroup(stringResource(R.string.mode_network)) { + val hint = when { + s.wifiDiscovery && !s.wifiDiscoveryLocation -> stringResource(R.string.mode_wifi_location_off) + !s.wifiDiscoveryPermission && s.wifiDiscoveryAsked -> stringResource(R.string.mode_wifi_permission_denied) + else -> stringResource(R.string.mode_wifi_discovery_hint) + } + SettingsRow(stringResource(R.string.mode_wifi_discovery), hint) { + Row(verticalAlignment = androidx.compose.ui.Alignment.CenterVertically, + horizontalArrangement = androidx.compose.foundation.layout.Arrangement.spacedBy(8.dp)) { + if (s.wifiDiscoveryBlocked || (s.wifiDiscovery && !s.wifiDiscoveryLocation)) { + SecondaryButton(stringResource(R.string.mode_wifi_open_settings), onClick = a.onWifiDiscoverySettings) + } + ToggleSwitch(s.wifiDiscovery, label = stringResource(R.string.mode_wifi_discovery)) { on -> + host.open = null + if (on) explainWifiDiscovery = true else a.onWifiDiscovery(false) + } + } + } + } if (steam && s.addedGamesDirs != null) SettingsGroup(stringResource(R.string.mode_added_games)) { for (dir in s.addedGamesDirs) { val n = s.addedGames.count { it.folderPath.startsWith("$dir/") } @@ -418,6 +446,19 @@ fun ModeSettingsPage(s: ModeSettings, a: ModeSettingsActions) { ) } } + if (explainWifiDiscovery) AlertDialog( + onDismissRequest = { explainWifiDiscovery = false }, + title = { Text(stringResource(R.string.mode_wifi_explain_title)) }, + text = { Text(stringResource(R.string.mode_wifi_explain_text)) }, + confirmButton = { + TextButton(onClick = { explainWifiDiscovery = false; a.onWifiDiscovery(true) }) { + Text(stringResource(if (s.wifiDiscoveryBlocked) R.string.mode_wifi_open_settings else R.string.mode_wifi_continue)) + } + }, + dismissButton = { + TextButton(onClick = { explainWifiDiscovery = false }) { Text(stringResource(R.string.common_cancel)) } + }, + ) if (confirmDeckyRemoval) AlertDialog( onDismissRequest = { confirmDeckyRemoval = false }, title = { Text(stringResource(R.string.mode_decky_remove_title)) }, diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 618b44821a..61200faa63 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -292,6 +292,15 @@ DirectAudio Microphone For voice chat. + Network + Wi-Fi discovery + Show Wi-Fi names and nearby networks in Steam. + Location services are off. + Location permission not granted. + Open settings + Continue + Enable Wi-Fi discovery? + Android requires Location permission to read Wi-Fi names and discover nearby networks. DroidDeck uses this access to show those networks in Steam. We don\'t track your location. Internet access works without this permission. Game storage Automatic - the SD card when present Automatic - the SD card when present (none now)