StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
refactor: coordinate typed app navigation
David Nashash56682962adfe
diff --git a/app/build.gradle.kts b/app/build.gradle.ktsindex 6479e22f..57dedb44 100644--- a/app/build.gradle.kts+++ b/app/build.gradle.kts@@ -501,6 +501,7 @@ dependencies {androidTestImplementation(composeBom)androidTestImplementation("androidx.compose.ui:ui-test-junit4")+ androidTestImplementation(libs.navigation.testing)androidTestImplementation(libs.androidx.test.ext.junit)androidTestImplementation(libs.espresso.core)androidTestImplementation(libs.truth)diff --git a/app/src/androidTest/java/com/streamvault/app/ui/AppNavigationContractTest.kt b/app/src/androidTest/java/com/streamvault/app/ui/AppNavigationContractTest.ktnew file mode 100644index 00000000..1d0b7063--- /dev/null+++ b/app/src/androidTest/java/com/streamvault/app/ui/AppNavigationContractTest.kt@@ -0,0 +1,156 @@+package com.streamvault.app.ui++import androidx.compose.runtime.LaunchedEffect+import androidx.compose.runtime.getValue+import androidx.compose.runtime.mutableStateOf+import androidx.compose.runtime.remember+import androidx.compose.runtime.setValue+import androidx.compose.ui.platform.LocalContext+import androidx.compose.ui.test.junit4.createComposeRule+import androidx.navigation.compose.ComposeNavigator+import androidx.navigation.compose.NavHost+import androidx.navigation.compose.composable+import androidx.navigation.compose.currentBackStackEntryAsState+import androidx.navigation.navArgument+import androidx.navigation.NavType+import androidx.navigation.testing.TestNavHostController+import androidx.test.ext.junit.runners.AndroidJUnit4+import com.google.common.truth.Truth.assertThat+import com.streamvault.app.navigation.AppRouteCodec+import com.streamvault.app.navigation.NavigationCommandEffect+import com.streamvault.app.navigation.NavControllerNavigator+import com.streamvault.app.navigation.PendingNavigationCommand+import com.streamvault.core.navigation.AppDestination+import com.streamvault.core.navigation.NavigationCommand+import com.streamvault.core.navigation.PlayerNavigationRequest+import org.junit.Rule+import org.junit.Test+import org.junit.runner.RunWith++@RunWith(AndroidJUnit4::class)+class AppNavigationContractTest {+ @get:Rule+ val composeRule = createComposeRule()++ @Test+ fun externalSearchCommandNavigatesOnceAndAcknowledges() {+ lateinit var navController: TestNavHostController+ var acknowledgementCount = 0+ var previousRouteAfterNavigation: String? = null++ composeRule.setContent {+ navController = rememberTestNavController()+ val currentEntry by navController.currentBackStackEntryAsState()+ var pending by remember {+ mutableStateOf<PendingNavigationCommand?>(+ PendingNavigationCommand(+ id = 1L,+ command = NavigationCommand.Navigate(AppDestination.Search("news"))+ )+ )+ }+ NavHost(navController = navController, startDestination = "home") {+ composable("home") {}+ composable(+ route = "search?query={query}",+ arguments = listOf(navArgument("query") { type = NavType.StringType })+ ) {}+ }+ NavigationCommandEffect(+ pending = pending,+ currentBackStackEntry = currentEntry,+ navigator = remember(navController) { NavControllerNavigator(navController) },+ acknowledge = {+ acknowledgementCount+++ pending = null+ }+ )+ }++ composeRule.waitUntil(5_000) {+ navController.currentBackStackEntry?.arguments?.getString("query") == "news"+ }+ composeRule.runOnIdle {+ previousRouteAfterNavigation = navController.previousBackStackEntry?.destination?.route+ }+ composeRule.waitForIdle()++ assertThat(acknowledgementCount).isEqualTo(1)+ assertThat(previousRouteAfterNavigation).isEqualTo("home")+ assertThat(navController.currentBackStackEntry?.arguments?.getString("query"))+ .isEqualTo("news")+ }++ @Test+ fun playerReturnCommandUsesTypedGuideDestination() {+ lateinit var navController: TestNavHostController+ var completedPhase = 0++ composeRule.setContent {+ navController = rememberTestNavController()+ val currentEntry by navController.currentBackStackEntryAsState()+ var pending by remember { mutableStateOf<PendingNavigationCommand?>(null) }+ LaunchedEffect(Unit) {+ navController.navigate(AppRouteCodec.encode(AppDestination.Guide()))+ pending = PendingNavigationCommand(+ id = 1L,+ command = NavigationCommand.OpenPlayer(+ PlayerNavigationRequest(+ streamUrl = "https://example.com/live.m3u8",+ title = "Guide channel",+ internalId = 42L,+ returnDestination = AppDestination.Guide()+ )+ )+ )+ }+ NavHost(navController = navController, startDestination = "home") {+ composable("home") {}+ composable(+ route = "epg?categoryId={categoryId}&anchorTime={anchorTime}&favoritesOnly={favoritesOnly}",+ arguments = listOf(+ navArgument("categoryId") { type = NavType.LongType; defaultValue = -1L },+ navArgument("anchorTime") { type = NavType.LongType; defaultValue = -1L },+ navArgument("favoritesOnly") { type = NavType.BoolType; defaultValue = false }+ )+ ) {}+ composable("player") {}+ }+ NavigationCommandEffect(+ pending = pending,+ currentBackStackEntry = currentEntry,+ navigator = remember(navController) { NavControllerNavigator(navController) },+ acknowledge = { id ->+ if (id == 1L) {+ pending = PendingNavigationCommand(+ id = 2L,+ command = NavigationCommand.ReturnTo(AppDestination.Guide())+ )+ } else {+ completedPhase = 2+ pending = null+ }+ }+ )+ }++ composeRule.waitUntil(5_000) { completedPhase == 2 }+ composeRule.runOnIdle {+ assertThat(navController.currentBackStackEntry?.destination?.route)+ .contains("epg")+ assertThat(navController.currentBackStackEntry?.arguments?.getLong("categoryId"))+ .isEqualTo(-1L)+ }+ }++ @androidx.compose.runtime.Composable+ private fun rememberTestNavController(): TestNavHostController {+ val context = LocalContext.current+ return remember(context) {+ TestNavHostController(context).apply {+ navigatorProvider.addNavigator(ComposeNavigator())+ }+ }+ }++}diff --git a/app/src/main/java/com/streamvault/app/MainActivity.kt b/app/src/main/java/com/streamvault/app/MainActivity.ktindex 664fa695..1bdcf0a9 100644--- a/app/src/main/java/com/streamvault/app/MainActivity.kt+++ b/app/src/main/java/com/streamvault/app/MainActivity.kt@@ -17,15 +17,10 @@ import com.streamvault.app.localization.resolveAppLocaleimport com.streamvault.app.navigation.AppNavigationimport com.streamvault.app.navigation.AppNavigationCoordinatorimport com.streamvault.app.navigation.ExternalNavigationRequestParser-import com.streamvault.app.navigation.StartupNavigationResolverimport com.streamvault.core.navigation.PlayerNavigationRequestimport com.streamvault.core.navigation.ExternalNavigationRequestimport com.streamvault.core.ui.theme.StreamVaultThemeimport com.streamvault.app.ui.time.LocalAppTimeFormat-import com.streamvault.domain.repository.ChannelRepository-import com.streamvault.domain.repository.CombinedM3uRepository-import com.streamvault.domain.repository.FavoriteRepository-import com.streamvault.domain.repository.PlaybackHistoryRepositoryimport com.streamvault.domain.repository.ProviderRepositoryimport dagger.hilt.android.AndroidEntryPoint@@ -73,18 +68,6 @@ class MainActivity : ComponentActivity() {@Injectlateinit var preferencesRepository: PreferencesRepository- @Inject- lateinit var combinedM3uRepository: CombinedM3uRepository-- @Inject- lateinit var favoriteRepository: FavoriteRepository-- @Inject- lateinit var playbackHistoryRepository: PlaybackHistoryRepository-- @Inject- lateinit var channelRepository: ChannelRepository-@Injectlateinit var providerRepository: ProviderRepository@@ -102,11 +85,6 @@ class MainActivity : ComponentActivity() {@Injectlateinit var externalNavigationRequestParser: ExternalNavigationRequestParser- @Inject- internal lateinit var startupNavigationResolver: StartupNavigationResolver-- internal val pendingNavigationCommand = appNavigationCoordinator.pendingCommand-private var playerPictureInPictureState = PlayerPictureInPictureState()override fun onCreate(savedInstanceState: Bundle?) {@@ -176,7 +154,7 @@ class MainActivity : ComponentActivity() {LocalAppTimeFormat provides appTimeFormat) {StreamVaultTheme {- AppNavigation(mainActivity = this@MainActivity)+ AppNavigation(coordinator = appNavigationCoordinator)}}}@@ -240,10 +218,6 @@ class MainActivity : ComponentActivity() {applyPlayerPictureInPictureParams()}- internal fun acknowledgeNavigationCommand(id: Long) {- appNavigationCoordinator.acknowledge(id)- }-fun openPlayer(request: PlayerNavigationRequest) {appNavigationCoordinator.submitExternalRequest(ExternalNavigationRequest.Player(request)diff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigation.ktindex ecc08035..0649c1dd 100644--- a/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt+++ b/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt@@ -1,217 +1,79 @@package com.streamvault.app.navigation-import android.net.Uri-import android.util.Logimport androidx.compose.runtime.Composableimport androidx.compose.runtime.LaunchedEffectimport androidx.compose.runtime.getValueimport androidx.compose.runtime.mutableStateOf-import androidx.compose.runtime.produceStateimport androidx.compose.runtime.remember-import androidx.compose.runtime.rememberCoroutineScopeimport androidx.compose.runtime.setValue-import androidx.lifecycle.Lifecycle-import androidx.lifecycle.LifecycleEventObserverimport androidx.lifecycle.compose.collectAsStateWithLifecycle-import androidx.lifecycle.compose.dropUnlessResumed+import androidx.navigation.NavBackStackEntryimport androidx.navigation.NavHostController-import androidx.navigation.NavOptionsBuilder-import androidx.navigation.NavType-import androidx.navigation.compose.NavHost-import androidx.navigation.compose.composableimport androidx.navigation.compose.currentBackStackEntryAsStateimport androidx.navigation.compose.rememberNavController-import androidx.navigation.navArgument-import com.streamvault.app.ui.model.isArchivePlayable-import com.streamvault.core.navigation.PlayerNavigationRequest-import com.streamvault.core.navigation.NavigationCommand-import com.streamvault.core.navigation.NavigationOptionsimport com.streamvault.core.navigation.AppDestination-import com.streamvault.domain.model.Channel-import com.streamvault.domain.model.Episode-import com.streamvault.domain.model.Movie-import com.streamvault.domain.repository.ChannelRepository-import com.streamvault.app.ui.screens.dashboard.DashboardScreen-import com.streamvault.app.ui.screens.multiview.MultiViewScreen-import com.streamvault.app.ui.screens.home.HomeScreen-import com.streamvault.app.ui.screens.movies.MoviesScreen-import com.streamvault.app.ui.screens.player.PlayerScreen-import com.streamvault.app.ui.screens.plugins.PluginsScreen-import com.streamvault.app.ui.screens.provider.ProviderSetupScreen-import com.streamvault.app.ui.screens.series.SeriesScreen-import com.streamvault.app.ui.screens.vod.VodScreen-import com.streamvault.app.ui.screens.settings.SettingsScreen-import com.streamvault.app.ui.screens.welcome.WelcomeScreen-import com.streamvault.app.ui.screens.downloads.DownloadsScreen-import com.streamvault.app.MainActivity-import com.streamvault.domain.model.AppLandingDestination-import com.streamvault.domain.model.AppTopLevelDestination-import com.streamvault.domain.model.ContentType-import com.streamvault.domain.model.CatalogLayout-import com.streamvault.domain.model.MovieDetailPresentationHint-import com.streamvault.domain.model.ActiveLiveSource-import com.streamvault.domain.model.Series-import com.streamvault.domain.model.SeriesDetailPresentationHint-import com.streamvault.domain.model.VirtualCategoryIds-import java.io.Serializable-import kotlin.coroutines.resume-import kotlinx.coroutines.flow.first-import kotlinx.coroutines.launch-import kotlinx.coroutines.suspendCancellableCoroutine-@Composable-fun AppNavigation(mainActivity: MainActivity) {- val navController = rememberNavController()+fun AppNavigation(+ coordinator: AppNavigationCoordinator,+ navController: NavHostController = rememberNavController()+) {val navigator = remember(navController) { NavControllerNavigator(navController) }- val currentBackStackEntry = navController.currentBackStackEntryAsState().value- val activeProvider = mainActivity.providerRepository.getActiveProvider()- .collectAsStateWithLifecycle(initialValue = null)- .value- var lastSplitCatalogType by remember(activeProvider?.id) { mutableStateOf(ContentType.MOVIE) }- var loadedSplitPreferenceProviderId by remember { mutableStateOf<Long?>(null) }- val navigationScope = rememberCoroutineScope()- LaunchedEffect(activeProvider?.id) {- val providerId = activeProvider?.id ?: return@LaunchedEffect- loadedSplitPreferenceProviderId = null- lastSplitCatalogType = mainActivity.preferencesRepository- .getLastSplitCatalogType(providerId)- .first()- loadedSplitPreferenceProviderId = providerId- }- val pendingNavigationCommand = mainActivity.pendingNavigationCommand.collectAsStateWithLifecycle().value- val topLevelDestinations = mainActivity.preferencesRepository.appTopLevelDestinations- .collectAsStateWithLifecycle(initialValue = AppTopLevelDestination.defaultOrder)- .value- val appLandingDestination = mainActivity.preferencesRepository.appLandingDestination- .collectAsStateWithLifecycle(initialValue = null)- .value- val resolvedLandingDestination = appLandingDestination?.let { landingDestination ->- AppTopLevelDestination.resolveLandingDestination(- preferred = landingDestination,- destinations = topLevelDestinations- )- }- // Route to land on when leaving the Welcome screen. For the "first favorite" / "last watched"- // landings this resolves to the Live TV tab (via toAppRoute); the channel itself is opened on top- // afterwards (see startupPlayerRequest below). This is computed immediately with no channel- // lookup, so Welcome is never held open long enough for a quick Back press to fall through the- // start destination and exit the app.- val startupRoute: String? = resolvedLandingDestination?.toAppRoute()+ val state by coordinator.state.collectAsStateWithLifecycle()+ val pending by coordinator.pendingCommand.collectAsStateWithLifecycle()+ val currentBackStackEntry by navController.currentBackStackEntryAsState()- // Deferred auto-play request for the live landings. Resolved off the Welcome screen so the app- // stays interactive on Live TV while the channel is looked up.- val startupPlayerRequest by produceState<PlayerNavigationRequest?>(- initialValue = null,- resolvedLandingDestination- ) {- val landing = resolvedLandingDestination- value = if (landing != null && requiresResolvedStartupTarget(landing)) {- resolveStartupPlayerRequest(mainActivity, landing)- } else {- null- }- }- var startupPlayerHandled by remember { mutableStateOf(false) }+ NavigationCommandEffect(+ pending = pending,+ currentBackStackEntry = currentBackStackEntry,+ navigator = navigator,+ acknowledge = coordinator::acknowledge+ )+ DestinationResumedEffect(currentBackStackEntry, coordinator::onDestinationResumed)- fun navigateToStartupTarget(popUpRoute: String): Boolean {- val route = startupRoute ?: return false- val destination = AppRouteCodec.decode(route) ?: return false- val popUpDestination = AppRouteCodec.decode(popUpRoute)- return navigator.navigateIfResumed(- destination,- NavigationOptions(popUpTo = popUpDestination, inclusive = true)- )- }+ AppNavHost(+ navController = navController,+ actions = navigator,+ catalogDetailActions = navigator,+ payloads = navigator,+ startupReady = state.startupTarget != null,+ onStartupNavigationRequested = coordinator::requestStartupNavigation,+ onTopLevelDestinationRequested = coordinator::requestTopLevelNavigation+ )+}- // Once the live landing has placed us on the Live TV tab, open the resolved channel on top of it.- // Opening on top of Live TV (instead of replacing it) means Back from the player returns into the- // app rather than exiting. Guarded so it fires once, and only while still on the freshly-landed- // Live TV tab, to avoid hijacking navigation after the user has started interacting.- LaunchedEffect(startupPlayerRequest, currentBackStackEntry) {- if (startupPlayerHandled) return@LaunchedEffect- val request = startupPlayerRequest ?: return@LaunchedEffect+@Composable+internal fun NavigationCommandEffect(+ pending: PendingNavigationCommand?,+ currentBackStackEntry: NavBackStackEntry?,+ navigator: NavControllerNavigator,+ acknowledge: (Long) -> Unit+) {+ var executingCommandId by remember { mutableStateOf<Long?>(null) }+ LaunchedEffect(pending?.id, currentBackStackEntry) {+ val command = pending ?: return@LaunchedEffectval entry = currentBackStackEntry ?: return@LaunchedEffect- val route = entry.destination?.route- if (route != Routes.LIVE_TV_DESTINATION && route != Routes.LIVE_TV) return@LaunchedEffect+ if (executingCommandId == command.id) return@LaunchedEffect+ executingCommandId = command.identry.lifecycle.awaitResumed()- if (navigator.execute(NavigationCommand.OpenPlayer(request))) {- startupPlayerHandled = true+ if (navigator.execute(command.command)) {+ acknowledge(command.id)+ } else {+ executingCommandId = null}}+}- LaunchedEffect(pendingNavigationCommand, currentBackStackEntry) {- val pending = pendingNavigationCommand ?: return@LaunchedEffect+@Composable+internal fun DestinationResumedEffect(+ currentBackStackEntry: NavBackStackEntry?,+ onDestinationResumed: (AppDestination) -> Unit+) {+ LaunchedEffect(currentBackStackEntry) {val entry = currentBackStackEntry ?: return@LaunchedEffectentry.lifecycle.awaitResumed()- if (navigator.execute(pending.command)) {- mainActivity.acknowledgeNavigationCommand(pending.id)- }- }-- // NAV-M02/NAV-H02: Single helper replacing repeated tab lambdas without serializing- // each tab's full UI tree into saved state on every switch.- fun tabNavigate(route: String) {- val entry = navController.currentBackStackEntry ?: return- if (!entry.lifecycle.currentState.isAtLeast(Lifecycle.State.RESUMED)) return- val currentRoute = entry.destination?.route- val provider = activeProvider- if (- provider?.catalogLayout == com.streamvault.domain.model.CatalogLayout.SPLIT &&- route in setOf(Routes.MOVIES, Routes.SERIES)- ) {- val selectedType = if (route == Routes.SERIES) ContentType.SERIES else ContentType.MOVIE- lastSplitCatalogType = selectedType- navigationScope.launch {- mainActivity.preferencesRepository.setLastSplitCatalogType(provider.id, selectedType)- }- }- val resolvedRoute = resolveCatalogRoute(- layout = provider?.catalogLayout,- requestedRoute = route,- lastSplitCatalogType = lastSplitCatalogType,- splitPreferenceReady = provider == null || loadedSplitPreferenceProviderId == provider.id- )- if (currentRoute == resolvedRoute || currentRoute?.startsWith("$resolvedRoute?") == true) return-- AppRouteCodec.decode(resolvedRoute)?.let { destination ->- navigator.navigateIfResumed(- destination,- NavigationOptions(- launchSingleTop = true,- restoreState = true,- saveState = true,- popUpTo = AppDestination.Welcome- )- )- }- }-- LaunchedEffect(activeProvider?.id, activeProvider?.catalogLayout, currentBackStackEntry?.destination?.route) {- val provider = activeProvider ?: return@LaunchedEffect- val route = currentBackStackEntry?.destination?.route ?: return@LaunchedEffect- val resolvedRoute = resolveCatalogRoute(- layout = provider.catalogLayout,- requestedRoute = route,- lastSplitCatalogType = lastSplitCatalogType,- splitPreferenceReady = loadedSplitPreferenceProviderId == provider.id- )- if (resolvedRoute != route) {- tabNavigate(resolvedRoute)- }+ entry.destination.route+ ?.let(AppRouteCodec::decode)+ ?.let(onDestinationResumed)}-- AppNavHost(- navController = navController,- actions = navigator,- catalogDetailActions = navigator,- payloads = navigator,- startupReady = startupRoute != null,- onStartupNavigationRequested = { popUpDestination ->- navigateToStartupTarget(AppRouteCodec.encode(popUpDestination))- },- onTopLevelDestinationRequested = { destination ->- tabNavigate(AppRouteCodec.encode(destination))- }- )}diff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigationPolicy.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigationPolicy.ktindex e334827c..7d2f883b 100644--- a/app/src/main/java/com/streamvault/app/navigation/AppNavigationPolicy.kt+++ b/app/src/main/java/com/streamvault/app/navigation/AppNavigationPolicy.kt@@ -1,14 +1,9 @@package com.streamvault.app.navigationimport com.streamvault.core.navigation.AppDestination-import com.streamvault.domain.model.AppLandingDestinationimport com.streamvault.domain.model.CatalogLayoutimport com.streamvault.domain.model.ContentType-internal fun requiresResolvedStartupTarget(landingDestination: AppLandingDestination): Boolean =- landingDestination == AppLandingDestination.FIRST_FAVORITE_LIVE ||- landingDestination == AppLandingDestination.LAST_WATCHED_LIVE-internal fun resolveCatalogDestination(layout: CatalogLayout?,requested: AppDestination,@@ -21,15 +16,3 @@ internal fun resolveCatalogDestination(if (lastSplitCatalogType == ContentType.SERIES) AppDestination.Series else AppDestination.Movieselse -> requested}--/** Temporary route adapter for the pre-coordinator root wiring. */-internal fun resolveCatalogRoute(- layout: CatalogLayout?,- requestedRoute: String,- lastSplitCatalogType: ContentType,- splitPreferenceReady: Boolean-): String = AppRouteCodec.decode(requestedRoute)?.let { decoded ->- AppRouteCodec.encode(- resolveCatalogDestination(layout, decoded, lastSplitCatalogType, splitPreferenceReady)- )-} ?: requestedRoutediff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigationStartupPolicy.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigationStartupPolicy.ktdeleted file mode 100644index 16911434..00000000--- a/app/src/main/java/com/streamvault/app/navigation/AppNavigationStartupPolicy.kt+++ /dev/null@@ -1,13 +0,0 @@-package com.streamvault.app.navigation--import com.streamvault.app.MainActivity-import com.streamvault.core.navigation.PlayerNavigationRequest-import com.streamvault.domain.model.AppLandingDestination--/** Temporary compatibility bridge for the pre-coordinator root wiring. */-internal suspend fun resolveStartupPlayerRequest(- mainActivity: MainActivity,- landingDestination: AppLandingDestination-): PlayerNavigationRequest? = mainActivity.startupNavigationResolver- .resolve(landingDestination)- .playerRequestdiff --git a/gradle/libs.versions.toml b/gradle/libs.versions.tomlindex ecaacf95..624fb117 100644--- a/gradle/libs.versions.toml+++ b/gradle/libs.versions.toml@@ -110,6 +110,7 @@ lifecycle-runtime-compose = { group = "androidx.lifecycle", name = "lifecycle-ru# Navigationnavigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigation-compose" }+navigation-testing = { group = "androidx.navigation", name = "navigation-testing", version.ref = "navigation-compose" }# Coroutinescoroutines-core = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-core", version.ref = "coroutines" }