Skip to content

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

refactor: add typed app route codec

David Nashash16609fe12d12
diff --git a/app/src/main/java/com/streamvault/app/navigation/AppRouteCodec.kt b/app/src/main/java/com/streamvault/app/navigation/AppRouteCodec.kt
new file mode 100644
index 00000000..6fe0335c
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/navigation/AppRouteCodec.kt
@@ -0,0 +1,187 @@
+package com.streamvault.app.navigation
+
+import android.net.Uri
+import com.streamvault.core.navigation.AppDestination
+import java.net.URLDecoder
+
+internal object AppRoutePatterns {
+ const val WELCOME = "welcome"
+ const val HOME = "home"
+ const val LIVE_TV = "live_tv"
+ const val LIVE_TV_DESTINATION = "live_tv?categoryId={categoryId}"
+ const val MOVIES = "movies"
+ const val SERIES = "series"
+ const val VOD = "vod"
+ const val DOWNLOADS = "downloads"
+ const val EPG = "epg"
+ const val EPG_DESTINATION =
+ "epg?categoryId={categoryId}&anchorTime={anchorTime}&favoritesOnly={favoritesOnly}"
+ const val SETTINGS = "settings"
+ const val SETTINGS_DESTINATION = "settings?backupUri={backupUri}"
+ const val PLUGINS = "plugins"
+ const val PLAYER = "player"
+ const val SEARCH = "search"
+ const val SEARCH_DESTINATION = "search?query={query}"
+ const val PROVIDER_SETUP = "provider_setup?providerId={providerId}&importUri={importUri}"
+ const val MOVIE_DETAIL = "movie_detail/{movieId}?returnRoute={returnRoute}"
+ const val SERIES_DETAIL = "series_detail/{seriesId}?returnRoute={returnRoute}"
+ const val PARENTAL_CONTROL_GROUPS = "parental_control_groups/{providerId}"
+ const val MULTI_VIEW = "multi_view"
+}
+
+internal object AppRouteCodec {
+ fun encode(destination: AppDestination): String = when (destination) {
+ AppDestination.Welcome -> AppRoutePatterns.WELCOME
+ AppDestination.Home -> AppRoutePatterns.HOME
+ is AppDestination.LiveTv -> destination.categoryId?.let { categoryId ->
+ "${AppRoutePatterns.LIVE_TV}?categoryId=$categoryId"
+ } ?: AppRoutePatterns.LIVE_TV
+ AppDestination.Movies -> AppRoutePatterns.MOVIES
+ AppDestination.Series -> AppRoutePatterns.SERIES
+ AppDestination.Vod -> AppRoutePatterns.VOD
+ AppDestination.Downloads -> AppRoutePatterns.DOWNLOADS
+ is AppDestination.Guide -> {
+ val categoryId = destination.categoryId ?: -1L
+ val anchorTime = destination.anchorTimeMs ?: -1L
+ "${AppRoutePatterns.EPG}?categoryId=$categoryId" +
+ "&anchorTime=$anchorTime&favoritesOnly=${destination.favoritesOnly}"
+ }
+ is AppDestination.Settings -> destination.backupUri?.takeIf(String::isNotBlank)?.let { uri ->
+ "${AppRoutePatterns.SETTINGS}?backupUri=${Uri.encode(uri)}"
+ } ?: AppRoutePatterns.SETTINGS
+ AppDestination.Plugins -> AppRoutePatterns.PLUGINS
+ is AppDestination.Search -> destination.query?.takeIf(String::isNotBlank)?.let { query ->
+ "${AppRoutePatterns.SEARCH}?query=${Uri.encode(query)}"
+ } ?: AppRoutePatterns.SEARCH
+ is AppDestination.ProviderSetup -> {
+ val providerId = destination.providerId ?: -1L
+ val importUri = Uri.encode(destination.importUri ?: "")
+ "${AppRoutePatterns.PROVIDER_SETUP.substringBefore('?')}?providerId=$providerId&importUri=$importUri"
+ }
+ is AppDestination.MovieDetail -> {
+ val returnRoute = destination.returnDestination?.let(::encode).orEmpty()
+ "movie_detail/${destination.movieId}?returnRoute=${Uri.encode(returnRoute)}"
+ }
+ is AppDestination.SeriesDetail -> {
+ val returnRoute = destination.returnDestination?.let(::encode).orEmpty()
+ "series_detail/${destination.seriesId}?returnRoute=${Uri.encode(returnRoute)}"
+ }
+ is AppDestination.ParentalControlGroups ->
+ "${AppRoutePatterns.PARENTAL_CONTROL_GROUPS.substringBefore("/{")}/${destination.providerId}"
+ AppDestination.Player -> AppRoutePatterns.PLAYER
+ AppDestination.MultiView -> AppRoutePatterns.MULTI_VIEW
+ }
+
+ fun decode(route: String): AppDestination? {
+ val normalizedRoute = route.trim()
+ if (normalizedRoute.isEmpty()) return null
+
+ val path = normalizedRoute.substringBefore('?')
+ val query = normalizedRoute.queryParameters()
+ return when {
+ path == AppRoutePatterns.WELCOME -> AppDestination.Welcome
+ path == AppRoutePatterns.HOME -> AppDestination.Home
+ path == AppRoutePatterns.LIVE_TV -> {
+ when {
+ !query.containsKey("categoryId") -> AppDestination.LiveTv()
+ else -> query["categoryId"]?.toLongOrNull()?.let { categoryId ->
+ AppDestination.LiveTv(normalizeSentinel(categoryId))
+ }
+ }
+ }
+ path == AppRoutePatterns.MOVIES -> AppDestination.Movies
+ path == AppRoutePatterns.SERIES -> AppDestination.Series
+ path == AppRoutePatterns.VOD -> AppDestination.Vod
+ path == AppRoutePatterns.DOWNLOADS -> AppDestination.Downloads
+ path == AppRoutePatterns.EPG -> decodeGuide(query)
+ path == AppRoutePatterns.SETTINGS -> AppDestination.Settings(
+ backupUri = query["backupUri"]?.takeIf(String::isNotBlank)
+ )
+ path == AppRoutePatterns.PLUGINS -> AppDestination.Plugins
+ path == AppRoutePatterns.PLAYER -> AppDestination.Player
+ path == AppRoutePatterns.MULTI_VIEW -> AppDestination.MultiView
+ path == AppRoutePatterns.SEARCH -> AppDestination.Search(
+ query["query"]?.takeIf(String::isNotBlank)
+ )
+ path == AppRoutePatterns.PROVIDER_SETUP.substringBefore('?') -> AppDestination.ProviderSetup(
+ providerId = query.longOrNull("providerId")?.let(::normalizeSentinel),
+ importUri = query["importUri"]?.takeIf(String::isNotBlank)
+ )
+ path.startsWith("movie_detail/") -> decodeMovieDetail(path, query)
+ path.startsWith("series_detail/") -> decodeSeriesDetail(path, query)
+ path.startsWith("parental_control_groups/") -> path
+ .substringAfter("parental_control_groups/")
+ .toLongOrNull()
+ ?.let { providerId -> runCatching { AppDestination.ParentalControlGroups(providerId) }.getOrNull() }
+ else -> null
+ }
+ }
+
+ fun decodeLegacyExternalRoute(route: String): AppDestination? = decode(route)?.let { destination ->
+ when (destination) {
+ AppDestination.Home,
+ AppDestination.Plugins,
+ is AppDestination.ProviderSetup,
+ is AppDestination.MovieDetail,
+ is AppDestination.SeriesDetail -> destination
+ else -> null
+ }
+ }
+
+ private fun decodeGuide(query: Map<String, String>): AppDestination? {
+ if (query.isEmpty()) return AppDestination.Guide()
+ val categoryId = if (query.containsKey("categoryId")) {
+ val rawCategoryId = query["categoryId"]?.toLongOrNull() ?: return null
+ normalizeSentinel(rawCategoryId)
+ } else {
+ null
+ }
+ val anchorTime = if (query.containsKey("anchorTime")) {
+ val rawAnchorTime = query["anchorTime"]?.toLongOrNull() ?: return null
+ normalizeSentinel(rawAnchorTime)
+ } else {
+ null
+ }
+ val favoritesOnly = query["favoritesOnly"]?.toBooleanStrictOrNull()
+ ?: if (query.containsKey("favoritesOnly")) return null else false
+ return AppDestination.Guide(categoryId, anchorTime, favoritesOnly)
+ }
+
+ private fun decodeMovieDetail(path: String, query: Map<String, String>): AppDestination? {
+ val movieId = path.substringAfter("movie_detail/").toLongOrNull() ?: return null
+ return runCatching {
+ AppDestination.MovieDetail(movieId, decodeReturnDestination(query["returnRoute"]))
+ }.getOrNull()
+ }
+
+ private fun decodeSeriesDetail(path: String, query: Map<String, String>): AppDestination? {
+ val seriesId = path.substringAfter("series_detail/").toLongOrNull() ?: return null
+ return runCatching {
+ AppDestination.SeriesDetail(seriesId, decodeReturnDestination(query["returnRoute"]))
+ }.getOrNull()
+ }
+
+ private fun decodeReturnDestination(value: String?): AppDestination? =
+ value?.takeIf(String::isNotBlank)?.let(::decode)
+
+ private fun normalizeSentinel(value: Long): Long? = value.takeUnless { it == -1L }
+
+ private fun Map<String, String>.longOrNull(key: String): Long? = this[key]?.toLongOrNull()
+}
+
+private fun String.queryParameters(): Map<String, String> {
+ val query = substringAfter('?', missingDelimiterValue = "")
+ if (query.isBlank()) return emptyMap()
+ return query.split('&')
+ .mapNotNull { entry ->
+ val key = entry.substringBefore('=', missingDelimiterValue = "")
+ .takeIf(String::isNotBlank)
+ ?: return@mapNotNull null
+ val rawValue = entry.substringAfter('=', missingDelimiterValue = "")
+ val value = runCatching { URLDecoder.decode(rawValue, Charsets.UTF_8.name()) }
+ .getOrNull()
+ ?: return@mapNotNull null
+ key to value
+ }
+ .toMap()
+}
diff --git a/app/src/test/java/com/streamvault/app/navigation/AppRouteCodecTest.kt b/app/src/test/java/com/streamvault/app/navigation/AppRouteCodecTest.kt
new file mode 100644
index 00000000..390d1b50
--- /dev/null
+++ b/app/src/test/java/com/streamvault/app/navigation/AppRouteCodecTest.kt
@@ -0,0 +1,74 @@
+package com.streamvault.app.navigation
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.core.navigation.AppDestination
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class AppRouteCodecTest {
+ @Test
+ fun typedDestinationsPreserveExistingRoutes() {
+ val cases = mapOf(
+ AppDestination.Home to "home",
+ AppDestination.LiveTv(42L) to "live_tv?categoryId=42",
+ AppDestination.Guide(21L, 1_700_000_000_000L, true) to
+ "epg?categoryId=21&anchorTime=1700000000000&favoritesOnly=true",
+ AppDestination.Search("night shift") to "search?query=night%20shift",
+ AppDestination.ProviderSetup(7L, "content://playlist/1") to
+ "provider_setup?providerId=7&importUri=content%3A%2F%2Fplaylist%2F1"
+ )
+
+ cases.forEach { (destination, route) ->
+ assertThat(AppRouteCodec.encode(destination)).isEqualTo(route)
+ assertThat(AppRouteCodec.decode(route)).isEqualTo(destination)
+ }
+ }
+
+ @Test
+ fun nestedReturnDestinationRoundTrips() {
+ val destination = AppDestination.SeriesDetail(
+ seriesId = 42L,
+ returnDestination = AppDestination.Search("night")
+ )
+
+ assertThat(AppRouteCodec.decode(AppRouteCodec.encode(destination)))
+ .isEqualTo(destination)
+ }
+
+ @Test
+ fun sentinelArgumentsDecodeAsNullValues() {
+ assertThat(AppRouteCodec.decode("live_tv?categoryId=-1"))
+ .isEqualTo(AppDestination.LiveTv())
+ assertThat(
+ AppRouteCodec.decode("epg?categoryId=-1&anchorTime=-1&favoritesOnly=false")
+ ).isEqualTo(AppDestination.Guide())
+ assertThat(AppRouteCodec.decode("provider_setup?providerId=-1&importUri="))
+ .isEqualTo(AppDestination.ProviderSetup())
+ }
+
+ @Test
+ fun malformedArgumentsReturnNullWithoutThrowing() {
+ assertThat(AppRouteCodec.decode("live_tv?categoryId=not-a-number")).isNull()
+ assertThat(AppRouteCodec.decode("movie_detail/not-a-number?returnRoute=home")).isNull()
+ assertThat(AppRouteCodec.decode("unknown?query=value")).isNull()
+ }
+
+ @Test
+ fun legacyExternalRoutesDecodeToTypedDestinations() {
+ assertThat(AppRouteCodec.decodeLegacyExternalRoute("home"))
+ .isEqualTo(AppDestination.Home)
+ assertThat(AppRouteCodec.decodeLegacyExternalRoute("plugins"))
+ .isEqualTo(AppDestination.Plugins)
+ assertThat(
+ AppRouteCodec.decodeLegacyExternalRoute(
+ "provider_setup?providerId=-1&importUri="
+ )
+ ).isEqualTo(AppDestination.ProviderSetup())
+ assertThat(
+ AppRouteCodec.decodeLegacyExternalRoute("series_detail/42?returnRoute=home")
+ ).isEqualTo(AppDestination.SeriesDetail(42L, AppDestination.Home))
+ assertThat(AppRouteCodec.decodeLegacyExternalRoute("settings")).isNull()
+ }
+}
diff --git a/app/src/test/java/com/streamvault/app/navigation/ExternalDestinationTest.kt b/app/src/test/java/com/streamvault/app/navigation/ExternalDestinationTest.kt
index aba8515f..d77a52c1 100644
--- a/app/src/test/java/com/streamvault/app/navigation/ExternalDestinationTest.kt
+++ b/app/src/test/java/com/streamvault/app/navigation/ExternalDestinationTest.kt
@@ -1,44 +1,29 @@
package com.streamvault.app.navigation
import com.google.common.truth.Truth.assertThat
+import com.streamvault.core.navigation.AppDestination
import org.junit.Test
class ExternalDestinationTest {
-
- @Test
- fun fromLegacyRoute_parsesSupportedRoutes() {
- assertThat(ExternalDestination.fromLegacyRoute("home"))
- .isEqualTo(ExternalDestination.Home)
- assertThat(ExternalDestination.fromLegacyRoute("provider_setup?providerId=-1&importUri="))
- .isEqualTo(ExternalDestination.ProviderSetup())
- assertThat(
- ExternalDestination.fromLegacyRoute(
- "series_detail/42?returnRoute=home"
- )
- ).isEqualTo(
- ExternalDestination.SeriesDetail(seriesId = 42L, returnRoute = "home")
- )
- }
-
- @Test
- fun fromLegacyRoute_rejectsUnsupportedRoutes() {
- assertThat(ExternalDestination.fromLegacyRoute("settings"))
- .isNull()
- assertThat(ExternalDestination.fromLegacyRoute("series_detail/not-a-number"))
- .isNull()
- }
-
@Test
- fun fromLegacyRoute_decodesUtf8AndSkipsMalformedQueryValues() {
+ fun legacyRouteCompatibilityUsesTypedCodec() {
+ assertThat(AppRouteCodec.decodeLegacyExternalRoute("home"))
+ .isEqualTo(AppDestination.Home)
assertThat(
- ExternalDestination.fromLegacyRoute(
- "provider_setup?providerId=7&importUri=https%3A%2F%2Fexample.com%2Fguide%3Fname%3DCaf%C3%A9%2BTV&bad=%zz"
+ AppRouteCodec.decodeLegacyExternalRoute(
+ "provider_setup?providerId=7&importUri=https%3A%2F%2Fexample.com%2Fguide%3Fname%3DCaf%C3%A9%2BTV"
)
).isEqualTo(
- ExternalDestination.ProviderSetup(
+ AppDestination.ProviderSetup(
providerId = 7L,
importUri = "https://example.com/guide?name=Café+TV"
)
)
}
+
+ @Test
+ fun legacyRouteCompatibilityRejectsUnsupportedAndMalformedRoutes() {
+ assertThat(AppRouteCodec.decodeLegacyExternalRoute("settings")).isNull()
+ assertThat(AppRouteCodec.decodeLegacyExternalRoute("series_detail/not-a-number")).isNull()
+ }
}