diff --git a/app/src/main/kotlin/com/subtracks/data/net/LocalNetworkAccess.kt b/app/src/main/kotlin/com/subtracks/data/net/LocalNetworkAccess.kt index 979d84f3..4af79ca8 100644 --- a/app/src/main/kotlin/com/subtracks/data/net/LocalNetworkAccess.kt +++ b/app/src/main/kotlin/com/subtracks/data/net/LocalNetworkAccess.kt @@ -3,8 +3,10 @@ package com.subtracks.data.net import android.content.Context import android.content.pm.PackageManager import android.net.ConnectivityManager +import android.net.IpPrefix import android.net.LinkAddress import android.os.Build +import androidx.annotation.RequiresApi import androidx.core.content.ContextCompat import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext @@ -17,44 +19,45 @@ private const val LOCAL_NETWORK_PERMISSION_SDK = 37 class LocalNetworkAccess( private val context: Context, ) { + private val promptedAddresses = mutableSetOf() + suspend fun requiresPermission(address: String): Boolean { - if (Build.VERSION.SDK_INT < LOCAL_NETWORK_PERMISSION_SDK || granted()) return false + if (Build.VERSION.SDK_INT < LOCAL_NETWORK_PERMISSION_SDK) return false + if (granted()) return false val host = serverHost(address) ?: return false + if (isLocalHostname(host)) return true val linkAddresses = currentLinkAddresses() if (linkAddresses.isEmpty()) return false return withContext(Dispatchers.IO) { val resolved = runCatching { InetAddress.getAllByName(host).toList() }.getOrDefault(emptyList()) - resolved.any { candidate -> - linkAddresses.any { candidate.isWithinPrefix(it.address, it.prefixLength) } - } + resolved.any { candidate -> linkAddresses.any { it.contains(candidate) } } } } + @Synchronized + fun markPrompted(address: String) { + promptedAddresses += normalizeServerAddress(address) + } + + @Synchronized + fun wasPrompted(address: String): Boolean = normalizeServerAddress(address) in promptedAddresses + private fun granted(): Boolean = ContextCompat.checkSelfPermission(context, LOCAL_NETWORK_PERMISSION) == PackageManager.PERMISSION_GRANTED + @Suppress("DEPRECATION") private fun currentLinkAddresses(): List { val manager = context.getSystemService(ConnectivityManager::class.java) ?: return emptyList() - val network = manager.activeNetwork ?: return emptyList() - return manager.getLinkProperties(network)?.linkAddresses.orEmpty() + return manager.allNetworks.flatMap { network -> + manager.getLinkProperties(network)?.linkAddresses.orEmpty() + } } } -internal fun InetAddress.isWithinPrefix( - prefix: InetAddress, - prefixLength: Int, -): Boolean { - val own = address - val network = prefix.address - if (own.size != network.size || prefixLength !in 0..(own.size * 8)) return false - - val wholeBytes = prefixLength / 8 - for (index in 0 until wholeBytes) { - if (own[index] != network[index]) return false - } - - val remainingBits = prefixLength % 8 - if (remainingBits == 0) return true - val mask = (0xFF shl (8 - remainingBits)) and 0xFF - return (own[wholeBytes].toInt() and mask) == (network[wholeBytes].toInt() and mask) +internal fun isLocalHostname(host: String): Boolean { + val normalized = host.lowercase().trimEnd('.') + return normalized == "local" || normalized.endsWith(".local") } + +@RequiresApi(LOCAL_NETWORK_PERMISSION_SDK) +private fun LinkAddress.contains(address: InetAddress): Boolean = IpPrefix(this.address, prefixLength).contains(address) diff --git a/app/src/main/kotlin/com/subtracks/ui/AppRoot.kt b/app/src/main/kotlin/com/subtracks/ui/AppRoot.kt index 3af23158..aa29e899 100644 --- a/app/src/main/kotlin/com/subtracks/ui/AppRoot.kt +++ b/app/src/main/kotlin/com/subtracks/ui/AppRoot.kt @@ -66,6 +66,7 @@ import com.subtracks.data.model.Song import com.subtracks.data.repo.DownloadRepository import com.subtracks.data.repo.LibraryRepository import com.subtracks.data.repo.SourceRepository +import com.subtracks.data.sync.SyncManager import com.subtracks.playback.PlaybackController import com.subtracks.ui.components.AlbumInfoDialog import com.subtracks.ui.components.ArtistChooserSheet @@ -77,6 +78,7 @@ import com.subtracks.ui.components.MenuTarget import com.subtracks.ui.components.PlaylistInfoDialog import com.subtracks.ui.components.SongInfoDialog import com.subtracks.ui.components.rememberLocalNetworkGate +import com.subtracks.ui.components.rememberNetworkRevision import com.subtracks.ui.components.statusBarScrim import com.subtracks.ui.downloads.DownloadsRoute import com.subtracks.ui.home.HomeListRequest @@ -201,9 +203,16 @@ internal fun focusPops( @Composable fun SubtracksRoot(root: RootViewModel = koinViewModel()) { val localNetworkGate = rememberLocalNetworkGate() + val syncManager = koinInject() val serverAddress by root.serverAddress.collectAsStateWithLifecycle() - LaunchedEffect(serverAddress) { - localNetworkGate.run(address = serverAddress, onGranted = {}) + val networkRevision = rememberNetworkRevision() + LaunchedEffect(serverAddress, networkRevision) { + localNetworkGate.run( + address = serverAddress, + onGranted = { syncManager.requestSync() }, + onNotNeeded = {}, + automatic = true, + ) } when (val hasSource = root.hasSource.collectAsStateWithLifecycle().value) { null -> { diff --git a/app/src/main/kotlin/com/subtracks/ui/components/LocalNetworkGate.kt b/app/src/main/kotlin/com/subtracks/ui/components/LocalNetworkGate.kt index ad0f4013..aae28b82 100644 --- a/app/src/main/kotlin/com/subtracks/ui/components/LocalNetworkGate.kt +++ b/app/src/main/kotlin/com/subtracks/ui/components/LocalNetworkGate.kt @@ -1,17 +1,24 @@ package com.subtracks.ui.components +import android.net.ConnectivityManager +import android.net.LinkProperties +import android.net.Network import androidx.activity.compose.rememberLauncherForActivityResult import androidx.activity.result.contract.ActivityResultContracts import androidx.compose.material3.AlertDialog import androidx.compose.material3.Text import androidx.compose.material3.TextButton import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.runtime.setValue +import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.res.stringResource +import androidx.core.content.ContextCompat import com.subtracks.R import com.subtracks.data.net.LOCAL_NETWORK_PERMISSION import com.subtracks.data.net.LocalNetworkAccess @@ -22,22 +29,24 @@ import org.koin.compose.koinInject class LocalNetworkGate internal constructor( private val scope: CoroutineScope, private val checker: LocalNetworkAccess, - private val requestPermission: (onGranted: () -> Unit, onDenied: () -> Unit) -> Unit, + private val requestPermission: (address: String, onGranted: () -> Unit, onDenied: () -> Unit) -> Unit, ) { fun run( address: String?, onGranted: () -> Unit, onDenied: () -> Unit = {}, + onNotNeeded: () -> Unit = onGranted, + automatic: Boolean = false, ) { if (address == null) { - onGranted() + onNotNeeded() return } scope.launch { - if (checker.requiresPermission(address)) { - requestPermission(onGranted, onDenied) + if (!checker.requiresPermission(address) || (automatic && checker.wasPrompted(address))) { + onNotNeeded() } else { - onGranted() + requestPermission(address, onGranted, onDenied) } } } @@ -65,8 +74,11 @@ fun rememberLocalNetworkGate(): LocalNetworkGate { } val gate = - LocalNetworkGate(scope, checker) { onGranted, onDenied -> - pending = PendingRequest(onGranted, onDenied) + LocalNetworkGate(scope, checker) { address, onGranted, onDenied -> + if (pending == null) { + checker.markPrompted(address) + pending = PendingRequest(onGranted, onDenied) + } } val request = pending @@ -102,3 +114,35 @@ fun rememberLocalNetworkGate(): LocalNetworkGate { } return gate } + +@Composable +internal fun rememberNetworkRevision(): Int { + val context = LocalContext.current + var revision by remember { mutableIntStateOf(0) } + DisposableEffect(context) { + val manager = context.getSystemService(ConnectivityManager::class.java) + val mainExecutor = ContextCompat.getMainExecutor(context) + val callback = + object : ConnectivityManager.NetworkCallback() { + override fun onAvailable(network: Network) { + mainExecutor.execute { revision++ } + } + + override fun onLost(network: Network) { + mainExecutor.execute { revision++ } + } + + override fun onLinkPropertiesChanged( + network: Network, + linkProperties: LinkProperties, + ) { + mainExecutor.execute { revision++ } + } + } + runCatching { manager?.registerDefaultNetworkCallback(callback) } + onDispose { + if (manager != null) runCatching { manager.unregisterNetworkCallback(callback) } + } + } + return revision +} diff --git a/app/src/test/kotlin/com/subtracks/data/net/LocalNetworkAccessTest.kt b/app/src/test/kotlin/com/subtracks/data/net/LocalNetworkAccessTest.kt index fe82c5ce..5cbe7465 100644 --- a/app/src/test/kotlin/com/subtracks/data/net/LocalNetworkAccessTest.kt +++ b/app/src/test/kotlin/com/subtracks/data/net/LocalNetworkAccessTest.kt @@ -4,46 +4,15 @@ import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue import org.junit.Test -import java.net.InetAddress class LocalNetworkAccessTest { @Test - fun matchesAnAddressInsideASlash24Network() { - assertTrue(address("192.168.1.122").isWithinPrefix(address("192.168.1.243"), 24)) - } - - @Test - fun rejectsAnAddressOutsideASlash24Network() { - assertFalse(address("10.224.202.10").isWithinPrefix(address("192.168.22.11"), 24)) - } - - @Test - fun matchesAnAddressInsideASlash8Network() { - assertTrue(address("10.224.202.10").isWithinPrefix(address("10.0.0.1"), 8)) - } - - @Test - fun masksThePartialByteOfANonOctetPrefix() { - assertTrue(address("192.168.1.200").isWithinPrefix(address("192.168.1.130"), 25)) - assertFalse(address("192.168.1.100").isWithinPrefix(address("192.168.1.130"), 25)) - } - - @Test - fun doesNotMatchAcrossAddressFamilies() { - assertFalse(address("::1").isWithinPrefix(address("10.0.0.1"), 8)) - assertFalse(address("10.0.0.1").isWithinPrefix(address("fd00::1"), 64)) - } - - @Test - fun matchesAnIpv6Prefix() { - assertTrue(address("fd00:1234:5678:9abc::5").isWithinPrefix(address("fd00:1234:5678:9abc::1"), 64)) - assertFalse(address("fd00:1234:5678:9abd::5").isWithinPrefix(address("fd00:1234:5678:9abc::1"), 64)) - } - - @Test - fun matchesAHostRoute() { - assertTrue(address("10.0.0.5").isWithinPrefix(address("10.0.0.5"), 32)) - assertFalse(address("10.0.0.6").isWithinPrefix(address("10.0.0.5"), 32)) + fun treatsDotLocalHostnamesAsLocalNetwork() { + assertTrue(isLocalHostname("navidrome.local")) + assertTrue(isLocalHostname("NAVIDROME.LOCAL.")) + assertTrue(isLocalHostname("local")) + assertFalse(isLocalHostname("navidrome.example.com")) + assertFalse(isLocalHostname("local.example.com")) } @Test @@ -52,6 +21,4 @@ class LocalNetworkAccessTest { assertEquals("navidrome.example.com", serverHost("navidrome.example.com:4533")) assertEquals("10.224.202.10", serverHost("http://10.224.202.10")) } - - private fun address(value: String): InetAddress = InetAddress.getByName(value) }