StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
Filter unhealthy playback DNS addresses
Ensar Basri Kahvecifd5eb255d1c2
diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerAddressHealthEventListener.kt b/player/src/main/java/com/streamvault/player/playback/PlayerAddressHealthEventListener.ktnew file mode 100644index 00000000..dca81398--- /dev/null+++ b/player/src/main/java/com/streamvault/player/playback/PlayerAddressHealthEventListener.kt@@ -0,0 +1,67 @@+package com.streamvault.player.playback++import java.io.IOException+import java.net.InetSocketAddress+import java.net.Proxy+import java.util.concurrent.ConcurrentHashMap+import okhttp3.Call+import okhttp3.EventListener+import okhttp3.Protocol++internal class PlayerAddressHealthEventListener(+ private val healthStore: PlayerAddressHealthStore+) : EventListener() {+ private data class ConnectedAddress(+ val hostname: String,+ val port: Int,+ val address: java.net.InetAddress?+ )++ private val connectedAddresses = ConcurrentHashMap<Call, ConnectedAddress>()++ override fun connectEnd(+ call: Call,+ inetSocketAddress: InetSocketAddress,+ proxy: Proxy,+ protocol: Protocol?+ ) {+ val connectedAddress = ConnectedAddress(+ hostname = call.request().url.host,+ port = inetSocketAddress.port,+ address = inetSocketAddress.address+ )+ connectedAddresses[call] = connectedAddress+ healthStore.markHealthy(+ hostname = connectedAddress.hostname,+ port = connectedAddress.port,+ address = connectedAddress.address+ )+ }++ override fun connectFailed(+ call: Call,+ inetSocketAddress: InetSocketAddress,+ proxy: Proxy,+ protocol: Protocol?,+ ioe: IOException+ ) {+ healthStore.markUnhealthy(+ hostname = call.request().url.host,+ port = inetSocketAddress.port,+ address = inetSocketAddress.address+ )+ }++ override fun callEnd(call: Call) {+ connectedAddresses.remove(call)+ }++ override fun callFailed(call: Call, ioe: IOException) {+ val connectedAddress = connectedAddresses.remove(call) ?: return+ healthStore.markUnhealthy(+ hostname = connectedAddress.hostname,+ port = connectedAddress.port,+ address = connectedAddress.address+ )+ }+}diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerAddressHealthStore.kt b/player/src/main/java/com/streamvault/player/playback/PlayerAddressHealthStore.ktnew file mode 100644index 00000000..f1f2e091--- /dev/null+++ b/player/src/main/java/com/streamvault/player/playback/PlayerAddressHealthStore.kt@@ -0,0 +1,68 @@+package com.streamvault.player.playback++import java.net.InetAddress+import java.util.Locale+import java.util.concurrent.ConcurrentHashMap++internal enum class PlayerAddressHealth {+ HEALTHY,+ UNKNOWN,+ UNHEALTHY+}++internal class PlayerAddressHealthStore(+ private val healthyTtlMs: Long = DEFAULT_HEALTHY_TTL_MS,+ val failureTtlMs: Long = DEFAULT_FAILURE_TTL_MS,+ private val clock: () -> Long = System::currentTimeMillis+) {+ private data class AddressKey(+ val hostname: String,+ val port: Int,+ val address: String+ )++ private data class Entry(+ val health: PlayerAddressHealth,+ val updatedAtMs: Long+ )++ private val entries = ConcurrentHashMap<AddressKey, Entry>()++ fun markHealthy(hostname: String, port: Int, address: InetAddress?) {+ if (address == null) return+ entries[key(hostname, port, address)] = Entry(PlayerAddressHealth.HEALTHY, clock())+ }++ fun markUnhealthy(hostname: String, port: Int, address: InetAddress?) {+ if (address == null) return+ entries[key(hostname, port, address)] = Entry(PlayerAddressHealth.UNHEALTHY, clock())+ }++ fun health(hostname: String, port: Int, address: InetAddress): PlayerAddressHealth {+ val key = key(hostname, port, address)+ val entry = entries[key] ?: return PlayerAddressHealth.UNKNOWN+ val ttlMs = when (entry.health) {+ PlayerAddressHealth.HEALTHY -> healthyTtlMs+ PlayerAddressHealth.UNHEALTHY -> failureTtlMs+ PlayerAddressHealth.UNKNOWN -> 0L+ }+ if (clock() - entry.updatedAtMs > ttlMs) {+ entries.remove(key, entry)+ return PlayerAddressHealth.UNKNOWN+ }+ return entry.health+ }++ private fun key(hostname: String, port: Int, address: InetAddress): AddressKey {+ return AddressKey(+ hostname = hostname.lowercase(Locale.US),+ port = port,+ address = address.hostAddress.orEmpty()+ )+ }++ private companion object {+ const val DEFAULT_HEALTHY_TTL_MS = 10 * 60 * 1_000L+ const val DEFAULT_FAILURE_TTL_MS = 2 * 60 * 1_000L+ }+}diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.kt b/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.ktindex 9e97f649..f7a3b865 100644--- a/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.kt+++ b/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.kt@@ -8,6 +8,7 @@ import androidx.media3.datasource.DataSourceimport androidx.media3.datasource.okhttp.OkHttpDataSourceimport com.streamvault.domain.model.VodHttpProtocolModeimport com.streamvault.domain.model.StreamInfo+import java.net.URIimport java.util.concurrent.ConcurrentHashMapimport java.util.concurrent.TimeUnitimport okhttp3.OkHttpClient@@ -20,9 +21,11 @@ class PlayerDataSourceFactoryProvider() {private data class ClientKey(val profile: PlayerTimeoutProfile,- val forceHttp1: Boolean+ val forceHttp1: Boolean,+ val port: Int)+ private val addressHealthStore = PlayerAddressHealthStore()private val clientsByKey = ConcurrentHashMap<ClientKey, OkHttpClient>()fun createFactory(@@ -37,11 +40,14 @@ class PlayerDataSourceFactoryProvider(resolvedStreamType = resolvedStreamType,vodHttpProtocolMode = vodHttpProtocolMode)- val client = clientsByKey.computeIfAbsent(ClientKey(profile, forceHttp1)) {+ val port = streamPort(streamInfo.url)+ val client = clientsByKey.computeIfAbsent(ClientKey(profile, forceHttp1, port)) {baseClient.newBuilder().connectTimeout(profile.connectTimeoutMs, TimeUnit.MILLISECONDS).readTimeout(profile.readTimeoutMs, TimeUnit.MILLISECONDS).writeTimeout(profile.writeTimeoutMs, TimeUnit.MILLISECONDS)+ .dns(PlayerDnsPolicy.healthAwareDns(port = port, healthStore = addressHealthStore))+ .eventListener(PlayerAddressHealthEventListener(addressHealthStore)).apply {if (forceHttp1) {protocols(listOf(Protocol.HTTP_1_1))@@ -62,6 +68,16 @@ class PlayerDataSourceFactoryProvider(return profile to factory}+ private fun streamPort(url: String): Int {+ val uri = runCatching { URI(url) }.getOrNull()+ uri?.port?.takeIf { it > 0 }?.let { return it }+ return when (uri?.scheme?.lowercase()) {+ "http" -> 80+ "https" -> 443+ else -> -1+ }+ }+private companion object {const val TAG = "PlayerDataSourceFactory"}diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerDnsPolicy.kt b/player/src/main/java/com/streamvault/player/playback/PlayerDnsPolicy.ktnew file mode 100644index 00000000..94500202--- /dev/null+++ b/player/src/main/java/com/streamvault/player/playback/PlayerDnsPolicy.kt@@ -0,0 +1,53 @@+package com.streamvault.player.playback++import java.net.InetAddress+import okhttp3.Dns++internal object PlayerDnsPolicy {+ fun healthAwareDns(+ port: Int,+ healthStore: PlayerAddressHealthStore,+ delegate: Dns = Dns.SYSTEM+ ): Dns {+ return object : Dns {+ override fun lookup(hostname: String): List<InetAddress> {+ return sortForPlayback(+ hostname = hostname,+ port = port,+ addresses = delegate.lookup(hostname),+ healthStore = healthStore+ )+ }+ }+ }++ fun sortForPlayback(+ hostname: String,+ port: Int,+ addresses: List<InetAddress>,+ healthStore: PlayerAddressHealthStore+ ): List<InetAddress> {+ val addressesWithHealth = addresses.map { address ->+ address to healthStore.health(hostname, port, address)+ }+ val hasHealthierAlternative = addressesWithHealth.any { (_, health) ->+ health != PlayerAddressHealth.UNHEALTHY+ }+ return addressesWithHealth+ .let { entries ->+ if (hasHealthierAlternative) {+ entries.filterNot { (_, health) -> health == PlayerAddressHealth.UNHEALTHY }+ } else {+ entries+ }+ }+ .sortedBy { (_, health) ->+ when (health) {+ PlayerAddressHealth.HEALTHY -> 0+ PlayerAddressHealth.UNKNOWN -> 1+ PlayerAddressHealth.UNHEALTHY -> 2+ }+ }+ .map { (address, _) -> address }+ }+}diff --git a/player/src/test/java/com/streamvault/player/playback/PlayerAddressHealthEventListenerTest.kt b/player/src/test/java/com/streamvault/player/playback/PlayerAddressHealthEventListenerTest.ktnew file mode 100644index 00000000..99cbfe0d--- /dev/null+++ b/player/src/test/java/com/streamvault/player/playback/PlayerAddressHealthEventListenerTest.kt@@ -0,0 +1,59 @@+package com.streamvault.player.playback++import com.google.common.truth.Truth.assertThat+import java.io.IOException+import java.net.InetAddress+import java.net.InetSocketAddress+import java.net.Proxy+import okhttp3.Call+import okhttp3.Callback+import okhttp3.Protocol+import okhttp3.Request+import okhttp3.Response+import okio.Timeout+import org.junit.Test++class PlayerAddressHealthEventListenerTest {++ @Test+ fun `callFailed marks the last connected address unhealthy`() {+ val address = InetAddress.getByName("192.0.2.10")+ val socketAddress = InetSocketAddress(address, 443)+ val healthStore = PlayerAddressHealthStore()+ val listener = PlayerAddressHealthEventListener(healthStore)+ val call = FakeCall("https://example.test/movie.mkv")++ listener.connectEnd(call, socketAddress, Proxy.NO_PROXY, Protocol.HTTP_1_1)+ assertThat(healthStore.health("example.test", 443, address))+ .isEqualTo(PlayerAddressHealth.HEALTHY)++ listener.callFailed(call, IOException("read timeout"))++ assertThat(healthStore.health("example.test", 443, address))+ .isEqualTo(PlayerAddressHealth.UNHEALTHY)+ }++ private class FakeCall(url: String) : Call {+ private val request = Request.Builder().url(url).build()++ override fun request(): Request = request++ override fun execute(): Response {+ error("Not used")+ }++ override fun enqueue(responseCallback: Callback) {+ error("Not used")+ }++ override fun cancel() = Unit++ override fun isExecuted(): Boolean = false++ override fun isCanceled(): Boolean = false++ override fun timeout(): Timeout = Timeout.NONE++ override fun clone(): Call = FakeCall(request.url.toString())+ }+}diff --git a/player/src/test/java/com/streamvault/player/playback/PlayerDnsPolicyTest.kt b/player/src/test/java/com/streamvault/player/playback/PlayerDnsPolicyTest.ktnew file mode 100644index 00000000..b5d23316--- /dev/null+++ b/player/src/test/java/com/streamvault/player/playback/PlayerDnsPolicyTest.kt@@ -0,0 +1,122 @@+package com.streamvault.player.playback++import com.google.common.truth.Truth.assertThat+import java.net.Inet4Address+import java.net.Inet6Address+import java.net.InetAddress+import org.junit.Test++class PlayerDnsPolicyTest {++ @Test+ fun `sortForPlayback keeps all addresses when no health is known`() {+ val ipv6 = InetAddress.getByName("2001:db8::1") as Inet6Address+ val ipv4 = InetAddress.getByName("192.0.2.10") as Inet4Address++ val sorted = PlayerDnsPolicy.sortForPlayback(+ hostname = "example.test",+ port = 443,+ addresses = listOf(ipv6, ipv4),+ healthStore = PlayerAddressHealthStore()+ )++ assertThat(sorted).containsExactly(ipv6, ipv4).inOrder()+ }++ @Test+ fun `sortForPlayback puts recently healthy addresses first regardless of address family`() {+ val ipv4a = InetAddress.getByName("192.0.2.10") as Inet4Address+ val ipv6 = InetAddress.getByName("2001:db8::1") as Inet6Address+ val ipv4b = InetAddress.getByName("192.0.2.20") as Inet4Address+ val healthStore = PlayerAddressHealthStore()++ healthStore.markHealthy("example.test", 443, ipv6)++ val sorted = PlayerDnsPolicy.sortForPlayback(+ hostname = "example.test",+ port = 443,+ addresses = listOf(ipv4a, ipv6, ipv4b),+ healthStore = healthStore+ )++ assertThat(sorted).containsExactly(ipv6, ipv4a, ipv4b).inOrder()+ }++ @Test+ fun `sortForPlayback filters recently failed addresses regardless of address family`() {+ val ipv6 = InetAddress.getByName("2001:db8::1") as Inet6Address+ val ipv4 = InetAddress.getByName("192.0.2.10") as Inet4Address+ val healthStore = PlayerAddressHealthStore()++ healthStore.markUnhealthy("example.test", 443, ipv4)++ val sorted = PlayerDnsPolicy.sortForPlayback(+ hostname = "example.test",+ port = 443,+ addresses = listOf(ipv4, ipv6),+ healthStore = healthStore+ )++ assertThat(sorted).containsExactly(ipv6)+ }++ @Test+ fun `sortForPlayback filters recently failed addresses when healthier alternatives exist`() {+ val failedIpv6 = InetAddress.getByName("2001:db8::1") as Inet6Address+ val unknownIpv4 = InetAddress.getByName("192.0.2.10") as Inet4Address+ val healthStore = PlayerAddressHealthStore()++ healthStore.markUnhealthy("example.test", 443, failedIpv6)++ val sorted = PlayerDnsPolicy.sortForPlayback(+ hostname = "example.test",+ port = 443,+ addresses = listOf(failedIpv6, unknownIpv4),+ healthStore = healthStore+ )++ assertThat(sorted).containsExactly(unknownIpv4)+ }++ @Test+ fun `sortForPlayback keeps failed addresses when every address is failed`() {+ val ipv6 = InetAddress.getByName("2001:db8::1") as Inet6Address+ val ipv4 = InetAddress.getByName("192.0.2.10") as Inet4Address+ val healthStore = PlayerAddressHealthStore()++ healthStore.markUnhealthy("example.test", 443, ipv6)+ healthStore.markUnhealthy("example.test", 443, ipv4)++ val sorted = PlayerDnsPolicy.sortForPlayback(+ hostname = "example.test",+ port = 443,+ addresses = listOf(ipv6, ipv4),+ healthStore = healthStore+ )++ assertThat(sorted).containsExactly(ipv6, ipv4).inOrder()+ }++ @Test+ fun `sortForPlayback forgets unhealthy addresses after failure ttl`() {+ var nowMs = 1_000L+ val ipv6 = InetAddress.getByName("2001:db8::1") as Inet6Address+ val ipv4 = InetAddress.getByName("192.0.2.10") as Inet4Address+ val healthStore = PlayerAddressHealthStore(+ failureTtlMs = 1_000L,+ clock = { nowMs }+ )++ healthStore.markUnhealthy("example.test", 443, ipv4)++ nowMs = 2_001L+ val sorted = PlayerDnsPolicy.sortForPlayback(+ hostname = "example.test",+ port = 443,+ addresses = listOf(ipv4, ipv6),+ healthStore = healthStore+ )++ assertThat(sorted).containsExactly(ipv4, ipv6).inOrder()+ }+}