diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 1afb6f4044..571a7d7399 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -12,6 +12,8 @@ android:usesPermissionFlags="neverForLocation" /> + + + @Inject + lateinit var jellyfinRepository: dagger.Lazy // For handling shortcut navigation - using StateFlow so composables can observe changes private val _pendingPlaylistNavigation = kotlinx.coroutines.flow.MutableStateFlow(null) private val _pendingShuffleAll = kotlinx.coroutines.flow.MutableStateFlow(false) @@ -280,6 +290,19 @@ class MainActivity : ComponentActivity() { } } + // Android 17+: servers configured before the app requested ACCESS_LOCAL_NETWORK + // (or after the user revoked it) silently time out. Ask once the app is usable. + val localNetworkGate = rememberLocalNetworkPermissionGate() + LaunchedEffect(showSetupScreen) { + if (showSetupScreen == false && LocalNetworkAccess.isPermissionRequired) { + val lanServerUrl = withContext(Dispatchers.IO) { savedSelfHostedServerUrls() } + .firstOrNull { LocalNetworkAccess.needsPermissionFor(this@MainActivity, it) } + if (lanServerUrl != null) { + localNetworkGate.ensureAccess(lanServerUrl) { } + } + } + } + // Check for crash log when app starts LaunchedEffect(Unit) { if (!isBenchmarkMode && CrashHandler.hasCrashLog()) { @@ -359,6 +382,11 @@ class MainActivity : ComponentActivity() { handleIntent(intent) } + private fun savedSelfHostedServerUrls(): List = listOfNotNull( + navidromeRepository.get().let { repo -> repo.serverUrl.takeIf { repo.isLoggedIn } }, + jellyfinRepository.get().let { repo -> repo.serverUrl.takeIf { repo.isLoggedIn } } + ) + private fun handleIntent(intent: Intent?) { if (intent == null) return diff --git a/app/src/main/java/com/theveloper/pixelplay/presentation/components/CastBottomSheet.kt b/app/src/main/java/com/theveloper/pixelplay/presentation/components/CastBottomSheet.kt index 502c61c441..a22cdb3cda 100644 --- a/app/src/main/java/com/theveloper/pixelplay/presentation/components/CastBottomSheet.kt +++ b/app/src/main/java/com/theveloper/pixelplay/presentation/components/CastBottomSheet.kt @@ -151,6 +151,7 @@ import androidx.compose.ui.graphics.Brush import androidx.compose.ui.input.pointer.pointerInput import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.unit.Velocity +import com.theveloper.pixelplay.utils.LocalNetworkAccess import com.theveloper.pixelplay.utils.shapes.RoundedStarShape import kotlinx.coroutines.Job import kotlinx.coroutines.isActive @@ -191,6 +192,10 @@ fun CastBottomSheet( if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) { add(Manifest.permission.NEARBY_WIFI_DEVICES) } + if (LocalNetworkAccess.isPermissionRequired) { + // Android 17+: cast discovery and the local media server need LAN access. + add(LocalNetworkAccess.PERMISSION) + } if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R) { add(Manifest.permission.ACCESS_FINE_LOCATION) } diff --git a/app/src/main/java/com/theveloper/pixelplay/presentation/components/LocalNetworkPermissionGate.kt b/app/src/main/java/com/theveloper/pixelplay/presentation/components/LocalNetworkPermissionGate.kt new file mode 100644 index 0000000000..80625a155e --- /dev/null +++ b/app/src/main/java/com/theveloper/pixelplay/presentation/components/LocalNetworkPermissionGate.kt @@ -0,0 +1,55 @@ +package com.theveloper.pixelplay.presentation.components + +import android.content.Context +import androidx.activity.compose.rememberLauncherForActivityResult +import androidx.activity.result.contract.ActivityResultContracts +import androidx.compose.runtime.Composable +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.ui.platform.LocalContext +import com.theveloper.pixelplay.utils.LocalNetworkAccess +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.launch + +/** + * Asks for [LocalNetworkAccess.PERMISSION] right before the app talks to a server on the local + * network, so self-hosted servers keep working on Android 17+. + */ +class LocalNetworkPermissionGate internal constructor( + private val context: Context, + private val scope: CoroutineScope, + private val requestPermission: (onResult: (Boolean) -> Unit) -> Unit +) { + /** + * Calls [onResult] with `true` when [serverUrl] can be reached: it is not on the local + * network, the permission is not needed on this device, or the user granted it. + */ + fun ensureAccess(serverUrl: String?, onResult: (granted: Boolean) -> Unit) { + scope.launch { + if (LocalNetworkAccess.needsPermissionFor(context, serverUrl)) { + requestPermission(onResult) + } else { + onResult(true) + } + } + } +} + +@Composable +fun rememberLocalNetworkPermissionGate(): LocalNetworkPermissionGate { + val context = LocalContext.current + val scope = rememberCoroutineScope() + val pendingResult = remember { arrayOfNulls<(Boolean) -> Unit>(1) } + val launcher = rememberLauncherForActivityResult( + contract = ActivityResultContracts.RequestPermission() + ) { granted -> + pendingResult[0]?.invoke(granted) + pendingResult[0] = null + } + return remember(context, scope, launcher) { + LocalNetworkPermissionGate(context, scope) { onResult -> + pendingResult[0] = onResult + launcher.launch(LocalNetworkAccess.PERMISSION) + } + } +} diff --git a/app/src/main/java/com/theveloper/pixelplay/presentation/jellyfin/auth/JellyfinLoginActivity.kt b/app/src/main/java/com/theveloper/pixelplay/presentation/jellyfin/auth/JellyfinLoginActivity.kt index 596e3d7dd5..7e4cb95bfb 100644 --- a/app/src/main/java/com/theveloper/pixelplay/presentation/jellyfin/auth/JellyfinLoginActivity.kt +++ b/app/src/main/java/com/theveloper/pixelplay/presentation/jellyfin/auth/JellyfinLoginActivity.kt @@ -54,6 +54,7 @@ import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier @@ -73,9 +74,11 @@ import androidx.compose.ui.unit.dp import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel import androidx.lifecycle.compose.collectAsStateWithLifecycle import com.theveloper.pixelplay.R +import com.theveloper.pixelplay.presentation.components.rememberLocalNetworkPermissionGate import com.theveloper.pixelplay.ui.theme.GoogleSansRounded import com.theveloper.pixelplay.ui.theme.PixelPlayTheme import dagger.hilt.android.AndroidEntryPoint +import kotlinx.coroutines.launch import racra.compose.smooth_corner_rect_library.AbsoluteSmoothCornerShape @AndroidEntryPoint @@ -102,12 +105,30 @@ fun JellyfinLoginScreen( val loginState by viewModel.state.collectAsStateWithLifecycle() val snackbarHostState = remember { SnackbarHostState() } val focusManager = LocalFocusManager.current + val coroutineScope = rememberCoroutineScope() + val localNetworkGate = rememberLocalNetworkPermissionGate() var serverUrl by remember { mutableStateOf("") } var username by remember { mutableStateOf("") } var password by remember { mutableStateOf("") } var passwordVisible by remember { mutableStateOf(false) } + // Android 17+ blocks LAN traffic without ACCESS_LOCAL_NETWORK: ask for it before connecting + // to a self-hosted server instead of letting the request time out. + fun submitLogin() { + localNetworkGate.ensureAccess(serverUrl) { granted -> + if (granted) { + viewModel.login(serverUrl, username, password) + } else { + coroutineScope.launch { + snackbarHostState.showSnackbar( + context.getString(R.string.auth_local_network_permission_denied) + ) + } + } + } + } + LaunchedEffect(loginState) { when (val state = loginState) { is JellyfinLoginState.Success -> { @@ -323,7 +344,7 @@ fun JellyfinLoginScreen( onDone = { focusManager.clearFocus() if (serverUrl.isNotBlank() && username.isNotBlank() && password.isNotBlank()) { - viewModel.login(serverUrl, username, password) + submitLogin() } } ), @@ -370,7 +391,7 @@ fun JellyfinLoginScreen( Button( onClick = { focusManager.clearFocus() - viewModel.login(serverUrl, username, password) + submitLogin() }, enabled = !isLoading && serverUrl.isNotBlank() && username.isNotBlank() && password.isNotBlank(), shape = AbsoluteSmoothCornerShape(18.dp, 60), diff --git a/app/src/main/java/com/theveloper/pixelplay/presentation/navidrome/auth/NavidromeLoginActivity.kt b/app/src/main/java/com/theveloper/pixelplay/presentation/navidrome/auth/NavidromeLoginActivity.kt index f7453547d6..94a43d9328 100644 --- a/app/src/main/java/com/theveloper/pixelplay/presentation/navidrome/auth/NavidromeLoginActivity.kt +++ b/app/src/main/java/com/theveloper/pixelplay/presentation/navidrome/auth/NavidromeLoginActivity.kt @@ -54,6 +54,7 @@ import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier @@ -73,9 +74,11 @@ import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.vector.ImageVector import androidx.compose.ui.res.vectorResource import com.theveloper.pixelplay.R +import com.theveloper.pixelplay.presentation.components.rememberLocalNetworkPermissionGate import com.theveloper.pixelplay.ui.theme.GoogleSansRounded import com.theveloper.pixelplay.ui.theme.PixelPlayTheme import dagger.hilt.android.AndroidEntryPoint +import kotlinx.coroutines.launch import racra.compose.smooth_corner_rect_library.AbsoluteSmoothCornerShape @AndroidEntryPoint @@ -102,12 +105,30 @@ fun NavidromeLoginScreen( val loginState by viewModel.state.collectAsStateWithLifecycle() val snackbarHostState = remember { SnackbarHostState() } val focusManager = LocalFocusManager.current + val coroutineScope = rememberCoroutineScope() + val localNetworkGate = rememberLocalNetworkPermissionGate() var serverUrl by remember { mutableStateOf("") } var username by remember { mutableStateOf("") } var password by remember { mutableStateOf("") } var passwordVisible by remember { mutableStateOf(false) } + // Android 17+ blocks LAN traffic without ACCESS_LOCAL_NETWORK: ask for it before connecting + // to a self-hosted server instead of letting the request time out. + fun submitLogin() { + localNetworkGate.ensureAccess(serverUrl) { granted -> + if (granted) { + viewModel.login(serverUrl, username, password) + } else { + coroutineScope.launch { + snackbarHostState.showSnackbar( + context.getString(R.string.auth_local_network_permission_denied) + ) + } + } + } + } + LaunchedEffect(loginState) { when (val state = loginState) { is NavidromeLoginState.Success -> { @@ -344,7 +365,7 @@ fun NavidromeLoginScreen( onDone = { focusManager.clearFocus() if (serverUrl.isNotBlank() && username.isNotBlank() && password.isNotBlank()) { - viewModel.login(serverUrl, username, password) + submitLogin() } } ), @@ -391,7 +412,7 @@ fun NavidromeLoginScreen( Button( onClick = { focusManager.clearFocus() - viewModel.login(serverUrl, username, password) + submitLogin() }, enabled = !isLoading && serverUrl.isNotBlank() && username.isNotBlank() && password.isNotBlank(), shape = AbsoluteSmoothCornerShape(18.dp, 60), diff --git a/app/src/main/java/com/theveloper/pixelplay/utils/LocalNetworkAccess.kt b/app/src/main/java/com/theveloper/pixelplay/utils/LocalNetworkAccess.kt new file mode 100644 index 0000000000..aa5bc4ad51 --- /dev/null +++ b/app/src/main/java/com/theveloper/pixelplay/utils/LocalNetworkAccess.kt @@ -0,0 +1,69 @@ +package com.theveloper.pixelplay.utils + +import android.Manifest +import android.content.Context +import android.content.pm.PackageManager +import android.os.Build +import androidx.core.content.ContextCompat +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import java.net.Inet6Address +import java.net.InetAddress +import java.net.URI + +/** + * Android 17 (API 37) blocks traffic to the local network for apps targeting SDK 37 unless they + * hold the runtime permission [Manifest.permission.ACCESS_LOCAL_NETWORK] (NEARBY_DEVICES group). + * Without it, connections to a LAN server simply time out. + * + * See https://developer.android.com/privacy-and-security/local-network-permission + */ +object LocalNetworkAccess { + + const val PERMISSION = Manifest.permission.ACCESS_LOCAL_NETWORK + + val isPermissionRequired: Boolean + get() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.CINNAMON_BUN + + fun isGranted(context: Context): Boolean = + !isPermissionRequired || + ContextCompat.checkSelfPermission(context, PERMISSION) == PackageManager.PERMISSION_GRANTED + + /** + * True when the permission is required on this device, not granted yet, and [serverUrl] + * points to the local network. + */ + suspend fun needsPermissionFor(context: Context, serverUrl: String?): Boolean = + !isGranted(context) && isLocalNetworkUrl(serverUrl) + + /** + * Whether [url] targets the local network: a private, link-local or unique-local address, a + * `.local` (mDNS) host, or a host name that resolves to one of those. Loopback is not local + * network traffic and is ignored. Resolution failures are treated as "not local". + */ + suspend fun isLocalNetworkUrl(url: String?): Boolean { + val host = extractHost(url) ?: return false + if (host.endsWith(".local", ignoreCase = true)) return true + return withContext(Dispatchers.IO) { + runCatching { InetAddress.getAllByName(host).any(::isLocalNetworkAddress) } + .getOrDefault(false) + } + } + + internal fun extractHost(url: String?): String? { + val trimmed = url?.trim().orEmpty() + if (trimmed.isEmpty()) return null + val withScheme = if ("://" in trimmed) trimmed else "http://$trimmed" + return runCatching { URI(withScheme).host } + .getOrNull() + ?.removeSurrounding("[", "]") + ?.takeIf { it.isNotBlank() } + } + + internal fun isLocalNetworkAddress(address: InetAddress): Boolean { + if (address.isLoopbackAddress || address.isAnyLocalAddress) return false + if (address.isSiteLocalAddress || address.isLinkLocalAddress) return true + // IPv6 unique local addresses (fc00::/7) are not covered by isSiteLocalAddress. + return address is Inet6Address && (address.address[0].toInt() and 0xFE) == 0xFC + } +} diff --git a/app/src/main/res/values-es/strings_cloud_services.xml b/app/src/main/res/values-es/strings_cloud_services.xml index 281b73b7a9..4676024e20 100644 --- a/app/src/main/res/values-es/strings_cloud_services.xml +++ b/app/src/main/res/values-es/strings_cloud_services.xml @@ -149,6 +149,7 @@ Usuario admin ¡Bienvenido, %1$s! + Permite el acceso a «Dispositivos cercanos» para conectar con un servidor de tu red local Compatible con Navidrome, Gonic, Airsonic y otros servidores Subsonic diff --git a/app/src/main/res/values/strings_cloud_services.xml b/app/src/main/res/values/strings_cloud_services.xml index df633dab6a..71fde90ff7 100644 --- a/app/src/main/res/values/strings_cloud_services.xml +++ b/app/src/main/res/values/strings_cloud_services.xml @@ -149,6 +149,7 @@ Username admin Welcome, %1$s! + Allow “Nearby devices” access to connect to a server on your local network Compatible with Navidrome, Gonic, Airsonic, and other Subsonic-compatible servers diff --git a/app/src/test/java/com/theveloper/pixelplay/utils/LocalNetworkAccessTest.kt b/app/src/test/java/com/theveloper/pixelplay/utils/LocalNetworkAccessTest.kt new file mode 100644 index 0000000000..3b2d8b2b4c --- /dev/null +++ b/app/src/test/java/com/theveloper/pixelplay/utils/LocalNetworkAccessTest.kt @@ -0,0 +1,40 @@ +package com.theveloper.pixelplay.utils + +import com.google.common.truth.Truth.assertThat +import java.net.InetAddress +import kotlinx.coroutines.test.runTest +import org.junit.Test + +class LocalNetworkAccessTest { + + @Test + fun extractHost_handlesSchemesPortsPathsAndIpv6() { + assertThat(LocalNetworkAccess.extractHost("http://192.168.1.10:4533")).isEqualTo("192.168.1.10") + assertThat(LocalNetworkAccess.extractHost(" https://music.example.com/rest ")).isEqualTo("music.example.com") + assertThat(LocalNetworkAccess.extractHost("192.168.1.10:8096")).isEqualTo("192.168.1.10") + assertThat(LocalNetworkAccess.extractHost("http://[fd00::1]:4533")).isEqualTo("fd00::1") + assertThat(LocalNetworkAccess.extractHost("")).isNull() + assertThat(LocalNetworkAccess.extractHost(null)).isNull() + } + + @Test + fun isLocalNetworkAddress_acceptsPrivateLinkLocalAndUniqueLocal() { + listOf("10.0.0.5", "172.16.3.4", "192.168.1.10", "169.254.10.20", "fe80::1", "fd12:3456::1") + .forEach { assertThat(LocalNetworkAccess.isLocalNetworkAddress(InetAddress.getByName(it))).isTrue() } + } + + @Test + fun isLocalNetworkAddress_rejectsLoopbackAndPublicAddresses() { + listOf("127.0.0.1", "::1", "0.0.0.0", "8.8.8.8", "2606:4700::1111", "172.32.0.1") + .forEach { assertThat(LocalNetworkAccess.isLocalNetworkAddress(InetAddress.getByName(it))).isFalse() } + } + + @Test + fun isLocalNetworkUrl_detectsLiteralLanAddressesAndMdnsHosts() = runTest { + assertThat(LocalNetworkAccess.isLocalNetworkUrl("http://192.168.1.10:4533")).isTrue() + assertThat(LocalNetworkAccess.isLocalNetworkUrl("http://navidrome.local:4533")).isTrue() + assertThat(LocalNetworkAccess.isLocalNetworkUrl("http://127.0.0.1:8080")).isFalse() + assertThat(LocalNetworkAccess.isLocalNetworkUrl("https://8.8.8.8")).isFalse() + assertThat(LocalNetworkAccess.isLocalNetworkUrl("")).isFalse() + } +}