Skip to content

StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.

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.kt
new file mode 100644
index 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.kt
new file mode 100644
index 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.kt
index 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.DataSource
import androidx.media3.datasource.okhttp.OkHttpDataSource
import com.streamvault.domain.model.VodHttpProtocolMode
import com.streamvault.domain.model.StreamInfo
+import java.net.URI
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.TimeUnit
import 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.kt
new file mode 100644
index 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.kt
new file mode 100644
index 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.kt
new file mode 100644
index 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()
+ }
+}