StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktindex 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.navigationimport com.google.common.truth.Truth.assertThat+import com.streamvault.core.navigation.AppDestinationimport org.junit.Testclass 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()+ }}