Skip to content

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

refactor: centralize typed navigation execution

David Nashash3245a20ebe85
diff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt
index 33d2dac9..d60d0025 100644
--- a/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt
+++ b/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt
@@ -24,6 +24,9 @@ import 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.NavigationOptions
+import com.streamvault.core.navigation.AppDestination
import com.streamvault.domain.model.Channel
import com.streamvault.domain.model.Episode
import com.streamvault.domain.model.Movie
@@ -60,6 +63,7 @@ import kotlinx.coroutines.suspendCancellableCoroutine
@Composable
fun AppNavigation(mainActivity: MainActivity) {
val navController = rememberNavController()
+ val navigator = remember(navController) { NavControllerNavigator(navController) }
val currentBackStackEntry = navController.currentBackStackEntryAsState().value
val activeProvider = mainActivity.providerRepository.getActiveProvider()
.collectAsStateWithLifecycle(initialValue = null)
@@ -112,9 +116,12 @@ fun AppNavigation(mainActivity: MainActivity) {
fun navigateToStartupTarget(popUpRoute: String): Boolean {
val route = startupRoute ?: return false
- return navController.navigateIfResumed(route) {
- popUpTo(popUpRoute) { inclusive = true }
- }
+ val destination = AppRouteCodec.decode(route) ?: return false
+ val popUpDestination = AppRouteCodec.decode(popUpRoute)
+ return navigator.navigateIfResumed(
+ destination,
+ NavigationOptions(popUpTo = popUpDestination, inclusive = true)
+ )
}
// Once the live landing has placed us on the Live TV tab, open the resolved channel on top of it.
@@ -128,7 +135,7 @@ fun AppNavigation(mainActivity: MainActivity) {
val route = entry.destination?.route
if (route != Routes.LIVE_TV_DESTINATION && route != Routes.LIVE_TV) return@LaunchedEffect
entry.lifecycle.awaitResumed()
- if (navController.navigateToPlayer(request)) {
+ if (navigator.execute(NavigationCommand.OpenPlayer(request))) {
startupPlayerHandled = true
}
}
@@ -136,7 +143,7 @@ fun AppNavigation(mainActivity: MainActivity) {
ExternalNavigationHost(
request = externalNavigationRequest,
currentBackStackEntry = currentBackStackEntry,
- navController = navController,
+ navigator = navigator,
onRequestHandled = mainActivity::clearExternalNavigationRequest
)
@@ -165,12 +172,16 @@ fun AppNavigation(mainActivity: MainActivity) {
)
if (currentRoute == resolvedRoute || currentRoute?.startsWith("$resolvedRoute?") == true) return
- navController.navigate(resolvedRoute) {
- popUpTo(navController.graph.startDestinationId) {
- saveState = true
- }
- launchSingleTop = true
- restoreState = true
+ AppRouteCodec.decode(resolvedRoute)?.let { destination ->
+ navigator.navigateIfResumed(
+ destination,
+ NavigationOptions(
+ launchSingleTop = true,
+ restoreState = true,
+ saveState = true,
+ popUpTo = AppDestination.Welcome
+ )
+ )
}
}
@@ -190,6 +201,7 @@ fun AppNavigation(mainActivity: MainActivity) {
AppNavigationGraph(
navController = navController,
+ navigator = navigator,
startupRoute = startupRoute,
navigateToStartupTarget = { popUpRoute -> navigateToStartupTarget(popUpRoute) },
tabNavigate = { route -> tabNavigate(route) }
diff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigationAdapters.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigationAdapters.kt
index 185025c4..63d52dee 100644
--- a/app/src/main/java/com/streamvault/app/navigation/AppNavigationAdapters.kt
+++ b/app/src/main/java/com/streamvault/app/navigation/AppNavigationAdapters.kt
@@ -1,137 +1,7 @@
package com.streamvault.app.navigation
-import com.streamvault.core.navigation.PlayerNavigationRequest
-import android.net.Uri
-import android.util.Log
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.produceState
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.lifecycle.Lifecycle
-import androidx.lifecycle.LifecycleEventObserver
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.lifecycle.compose.dropUnlessResumed
-import androidx.navigation.NavHostController
-import androidx.navigation.NavOptionsBuilder
-import androidx.navigation.NavType
-import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.composable
-import androidx.navigation.compose.currentBackStackEntryAsState
-import androidx.navigation.compose.rememberNavController
-import androidx.navigation.navArgument
-import com.streamvault.app.ui.model.isArchivePlayable
-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
-
-
-/** Navigate only when the current destination is fully resumed – prevents double-navigation during transitions. */
-internal fun NavHostController.navigateIfResumed(route: String, builder: NavOptionsBuilder.() -> Unit = {}): Boolean {
- if (currentBackStackEntry?.lifecycle?.currentState?.isAtLeast(Lifecycle.State.RESUMED) != true) return false
- navigate(route, builder)
- return true
-}
-
-internal suspend fun Lifecycle.awaitResumed() {
- if (currentState.isAtLeast(Lifecycle.State.RESUMED)) return
- suspendCancellableCoroutine { continuation ->
- lateinit var observer: LifecycleEventObserver
- observer = LifecycleEventObserver { _, _ ->
- when {
- currentState.isAtLeast(Lifecycle.State.RESUMED) -> {
- removeObserver(observer)
- if (continuation.isActive) continuation.resume(Unit)
- }
- currentState == Lifecycle.State.DESTROYED -> {
- removeObserver(observer)
- continuation.cancel()
- }
- }
- }
- addObserver(observer)
- continuation.invokeOnCancellation { removeObserver(observer) }
- }
-}
-
-internal fun NavHostController.navigateToPlayer(request: PlayerNavigationRequest): Boolean {
- if (currentBackStackEntry?.lifecycle?.currentState?.isAtLeast(Lifecycle.State.RESUMED) != true) return false
- currentBackStackEntry?.savedStateHandle?.set(PLAYER_REQUEST_KEY, request)
- navigate(Routes.PLAYER) { launchSingleTop = true }
- return true
-}
-
-internal fun NavHostController.navigateToMovieDetail(movie: Movie, returnRoute: String? = null): Boolean {
- if (currentBackStackEntry?.lifecycle?.currentState?.isAtLeast(Lifecycle.State.RESUMED) != true) return false
- currentBackStackEntry?.savedStateHandle?.set(MOVIE_DETAIL_PRESENTATION_HINT_KEY, movie.toMovieDetailPresentationHint())
- navigate(Routes.movieDetail(movie.id, returnRoute))
- return true
-}
-
-private fun Movie.toMovieDetailPresentationHint(): MovieDetailPresentationHint? {
- if (variants.isEmpty()) return null
- return MovieDetailPresentationHint(
- providerId = providerId,
- logicalGroupId = logicalGroupId,
- variants = variants,
- duplicateConfidence = duplicateConfidence
- )
-}
-
-internal fun NavHostController.navigateToSeriesDetail(series: Series, returnRoute: String? = null): Boolean {
- if (currentBackStackEntry?.lifecycle?.currentState?.isAtLeast(Lifecycle.State.RESUMED) != true) return false
- currentBackStackEntry?.savedStateHandle?.set(SERIES_DETAIL_PRESENTATION_HINT_KEY, series.toSeriesDetailPresentationHint())
- navigate(Routes.seriesDetail(series.id, returnRoute))
- return true
-}
-
-private fun Series.toSeriesDetailPresentationHint(): SeriesDetailPresentationHint? {
- if (variants.isEmpty()) return null
- return SeriesDetailPresentationHint(
- providerId = providerId,
- logicalGroupId = logicalGroupId,
- variants = variants,
- duplicateConfidence = duplicateConfidence
- )
-}
-
-internal fun NavHostController.navigateToExternalPlayer(request: PlayerNavigationRequest): Boolean {
- if (currentBackStackEntry?.lifecycle?.currentState?.isAtLeast(Lifecycle.State.RESUMED) != true) return false
- currentBackStackEntry?.savedStateHandle?.set(PLAYER_REQUEST_KEY, request)
- navigate(Routes.PLAYER) { launchSingleTop = true }
- return true
-}
internal fun AppLandingDestination.toAppRoute(): String = when (this) {
AppLandingDestination.HOME -> Routes.HOME
@@ -157,5 +27,3 @@ internal fun AppTopLevelDestination.toAppRoute(): String = when (this) {
AppTopLevelDestination.PLUGINS -> Routes.PLUGINS
AppTopLevelDestination.SETTINGS -> Routes.SETTINGS
}
-
-
diff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigationExternalNavigation.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigationExternalNavigation.kt
index fee486bb..e2db2afd 100644
--- a/app/src/main/java/com/streamvault/app/navigation/AppNavigationExternalNavigation.kt
+++ b/app/src/main/java/com/streamvault/app/navigation/AppNavigationExternalNavigation.kt
@@ -3,13 +3,15 @@ package com.streamvault.app.navigation
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.navigation.NavBackStackEntry
-import androidx.navigation.NavHostController
+import com.streamvault.core.navigation.AppDestination
+import com.streamvault.core.navigation.NavigationCommand
+import com.streamvault.core.navigation.NavigationOptions
@Composable
internal fun ExternalNavigationHost(
request: ExternalNavigationRequest?,
currentBackStackEntry: NavBackStackEntry?,
- navController: NavHostController,
+ navigator: NavControllerNavigator,
onRequestHandled: () -> Unit
) {
LaunchedEffect(request, currentBackStackEntry) {
@@ -17,31 +19,42 @@ internal fun ExternalNavigationHost(
entry.lifecycle.awaitResumed()
when (request) {
is ExternalNavigationRequest.Player -> {
- if (navController.navigateToExternalPlayer(request.request)) {
+ if (navigator.execute(NavigationCommand.OpenPlayer(request.request))) {
onRequestHandled()
}
}
is ExternalNavigationRequest.Destination -> {
- if (navController.navigateIfResumed(request.destination.toRoute()) { launchSingleTop = true }) {
+ val destination = AppRouteCodec.decode(request.destination.toRoute())
+ ?: AppDestination.Home
+ if (navigator.execute(NavigationCommand.Navigate(destination, NavigationOptions(launchSingleTop = true)))) {
onRequestHandled()
}
}
is ExternalNavigationRequest.ImportM3u -> {
- if (navController.navigateIfResumed(Routes.providerSetup(importUri = request.uri)) { launchSingleTop = true }) {
+ if (navigator.execute(NavigationCommand.Navigate(
+ AppDestination.ProviderSetup(importUri = request.uri),
+ NavigationOptions(launchSingleTop = true)
+ ))) {
onRequestHandled()
}
}
is ExternalNavigationRequest.ImportBackup -> {
- if (navController.navigateIfResumed(Routes.settings(backupUri = request.uri)) { launchSingleTop = true }) {
+ if (navigator.execute(NavigationCommand.Navigate(
+ AppDestination.Settings(backupUri = request.uri),
+ NavigationOptions(launchSingleTop = true)
+ ))) {
onRequestHandled()
}
}
is ExternalNavigationRequest.Search -> {
- if (navController.navigateIfResumed(Routes.search(request.query)) { launchSingleTop = true }) {
+ if (navigator.execute(NavigationCommand.Navigate(
+ AppDestination.Search(request.query),
+ NavigationOptions(launchSingleTop = true)
+ ))) {
onRequestHandled()
}
}
diff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigationGraph.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigationGraph.kt
index c9b6f522..f8cfe9a8 100644
--- a/app/src/main/java/com/streamvault/app/navigation/AppNavigationGraph.kt
+++ b/app/src/main/java/com/streamvault/app/navigation/AppNavigationGraph.kt
@@ -25,6 +25,8 @@ import androidx.navigation.navArgument
import com.streamvault.app.ui.model.isArchivePlayable
import com.streamvault.core.navigation.PlayerNavigationRequest
import com.streamvault.core.navigation.AppDestination
+import com.streamvault.core.navigation.NavigationOptions
+import com.streamvault.core.navigation.NavigationCommand
import com.streamvault.domain.model.Channel
import com.streamvault.domain.model.Episode
import com.streamvault.domain.model.Movie
@@ -45,10 +47,8 @@ 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
@@ -60,6 +60,7 @@ import kotlinx.coroutines.suspendCancellableCoroutine
@Composable
internal fun AppNavigationGraph(
navController: NavHostController,
+ navigator: NavControllerNavigator,
startupRoute: String?,
navigateToStartupTarget: (String) -> Boolean,
tabNavigate: (String) -> Unit
@@ -75,9 +76,10 @@ internal fun AppNavigationGraph(
},
startupReady = startupRoute != null,
onNavigateToSetup = dropUnlessResumed {
- navController.navigate(Routes.providerSetup()) {
- popUpTo(Routes.WELCOME) { inclusive = true }
- }
+ navigator.navigateIfResumed(
+ AppDestination.ProviderSetup(),
+ NavigationOptions(popUpTo = AppDestination.Welcome, inclusive = true)
+ )
}
)
}
@@ -95,7 +97,7 @@ internal fun AppNavigationGraph(
ProviderSetupScreen(
editProviderId = providerId,
initialImportUri = importUri,
- onBack = { navController.popBackStack() },
+ onBack = { navigator.back() },
onProviderAdded = dropUnlessResumed {
navigateToStartupTarget(Routes.PROVIDER_SETUP)
}
@@ -107,10 +109,10 @@ internal fun AppNavigationGraph(
DashboardScreen(
onNavigate = { route -> tabNavigate(route) },
onAddProvider = dropUnlessResumed {
- navController.navigate(Routes.providerSetup(null))
+ navigator.navigateIfResumed(AppDestination.ProviderSetup())
},
onRecentChannelClick = { channel, combinedProfileId ->
- navController.navigateToPlayer(
+ navigator.openPlayer(
channel.toLivePlayerRequest(
categoryId = com.streamvault.domain.model.VirtualCategoryIds.RECENT,
providerId = channel.providerId,
@@ -121,7 +123,7 @@ internal fun AppNavigationGraph(
)
},
onFavoriteChannelClick = { channel, combinedProfileId ->
- navController.navigateToPlayer(
+ navigator.openPlayer(
channel.toLivePlayerRequest(
categoryId = com.streamvault.domain.model.VirtualCategoryIds.FAVORITES,
providerId = channel.providerId,
@@ -132,10 +134,10 @@ internal fun AppNavigationGraph(
)
},
onMovieClick = { movie ->
- navController.navigateToMovieDetail(movie, Routes.HOME)
+ navigator.openMovieDetail(movie, AppDestination.Home)
},
onSeriesClick = { series ->
- navController.navigateToSeriesDetail(series, Routes.HOME)
+ navigator.openSeriesDetail(series, AppDestination.Home)
},
onPlaybackHistoryClick = { history ->
val route = when (history.contentType) {
@@ -154,9 +156,14 @@ internal fun AppNavigationGraph(
}
}
if (route is PlayerNavigationRequest) {
- navController.navigateToPlayer(route)
+ navigator.openPlayer(route)
} else {
- navController.navigateIfResumed(route as String) { launchSingleTop = true }
+ AppRouteCodec.decode(route as String)?.let { destination ->
+ navigator.navigateIfResumed(
+ destination,
+ NavigationOptions(launchSingleTop = true)
+ )
+ }
}
},
currentRoute = Routes.HOME
@@ -172,7 +179,7 @@ internal fun AppNavigationGraph(
val initialCategoryId = backStackEntry.arguments?.getLong("categoryId")?.takeIf { it != -1L }
HomeScreen(
onChannelClick = { channel, category, provider, combinedProfileId, combinedSourceFilterProviderId ->
- navController.navigateToPlayer(
+ navigator.openPlayer(
channel.toLivePlayerRequest(
categoryId = category?.id,
providerId = provider?.id,
@@ -193,10 +200,10 @@ internal fun AppNavigationGraph(
composable(Routes.MOVIES) {
MoviesScreen(
onMovieClick = { movie ->
- navController.navigateToMovieDetail(movie, Routes.MOVIES)
+ navigator.openMovieDetail(movie, AppDestination.Movies)
},
onContinueWatchingPlay = { history ->
- navController.navigateToPlayer(
+ navigator.openPlayer(
history.toPlayerNavigationRequest().copy(returnDestination = AppDestination.Movies)
)
},
@@ -208,10 +215,13 @@ internal fun AppNavigationGraph(
composable(Routes.SERIES) {
SeriesScreen(
onSeriesClick = { series ->
- navController.navigateToSeriesDetail(series, Routes.SERIES)
+ navigator.openSeriesDetail(series, AppDestination.Series)
},
onSeriesIdClick = { seriesId ->
- navController.navigateIfResumed(Routes.seriesDetail(seriesId, Routes.SERIES))
+ navigator.navigateIfResumed(
+ AppDestination.SeriesDetail(seriesId, AppDestination.Series),
+ NavigationOptions(launchSingleTop = true)
+ )
},
onNavigate = { route -> tabNavigate(route) },
currentRoute = Routes.SERIES
@@ -221,10 +231,10 @@ internal fun AppNavigationGraph(
composable(Routes.VOD) {
VodScreen(
onMovieClick = { movie ->
- navController.navigateToMovieDetail(movie, Routes.VOD)
+ navigator.openMovieDetail(movie, AppDestination.Vod)
},
onSeriesClick = { series ->
- navController.navigateToSeriesDetail(series, Routes.VOD)
+ navigator.openSeriesDetail(series, AppDestination.Vod)
},
onNavigate = { route -> tabNavigate(route) },
currentRoute = Routes.VOD
@@ -255,7 +265,7 @@ internal fun AppNavigationGraph(
initialAnchorTime = epgAnchorTime,
initialFavoritesOnly = epgFavoritesOnly,
onPlayChannel = { channel, categoryId, isVirtual, combinedProfileId, returnRoute ->
- navController.navigateToPlayer(
+ navigator.openPlayer(
channel.toLivePlayerRequest(
categoryId = categoryId,
providerId = channel.providerId,
@@ -269,7 +279,7 @@ internal fun AppNavigationGraph(
if (!channel.isArchivePlayable(program)) {
return@FullEpgScreen
}
- navController.navigateToPlayer(
+ navigator.openPlayer(
playerNavigationRequest(
streamUrl = channel.streamUrl,
title = channel.name,
@@ -301,13 +311,19 @@ internal fun AppNavigationGraph(
SettingsScreen(
onNavigate = { route -> tabNavigate(route) },
onAddProvider = dropUnlessResumed {
- navController.navigate(Routes.providerSetup(null))
+ navigator.navigateIfResumed(AppDestination.ProviderSetup())
},
onEditProvider = { provider ->
- navController.navigateIfResumed(Routes.providerSetup(provider.id))
+ navigator.navigateIfResumed(
+ AppDestination.ProviderSetup(providerId = provider.id),
+ NavigationOptions(launchSingleTop = true)
+ )
},
onNavigateToParentalControl = { providerId ->
- navController.navigateIfResumed(Routes.parentalControlGroups(providerId))
+ navigator.navigateIfResumed(
+ AppDestination.ParentalControlGroups(providerId),
+ NavigationOptions(launchSingleTop = true)
+ )
},
currentRoute = Routes.SETTINGS,
initialBackupImportUri = backupUri
@@ -330,7 +346,7 @@ internal fun AppNavigationGraph(
com.streamvault.app.ui.screens.settings.parental.ParentalControlGroupScreen(
currentRoute = Routes.SETTINGS,
onNavigate = { route -> tabNavigate(route) },
- onBack = { navController.popBackStack() }
+ onBack = { navigator.back() }
)
}
@@ -343,7 +359,7 @@ internal fun AppNavigationGraph(
com.streamvault.app.ui.screens.search.SearchScreen(
initialQuery = backStackEntry.arguments?.getString("query").orEmpty(),
onChannelClick = { channel ->
- navController.navigateToPlayer(
+ navigator.openPlayer(
channel.toLivePlayerRequest(
categoryId = channel.categoryId,
providerId = channel.providerId,
@@ -353,15 +369,15 @@ internal fun AppNavigationGraph(
)
},
onMovieClick = { movie ->
- navController.navigateToMovieDetail(
+ navigator.openMovieDetail(
movie,
- Routes.search(backStackEntry.arguments?.getString("query").orEmpty())
+ AppDestination.Search(backStackEntry.arguments?.getString("query").orEmpty())
)
},
onSeriesClick = { series ->
- navController.navigateToSeriesDetail(
+ navigator.openSeriesDetail(
series,
- Routes.search(backStackEntry.arguments?.getString("query").orEmpty())
+ AppDestination.Search(backStackEntry.arguments?.getString("query").orEmpty())
)
},
onNavigate = { route -> tabNavigate(route) },
@@ -370,19 +386,22 @@ internal fun AppNavigationGraph(
}
composable(route = Routes.PLAYER) { backStackEntry ->
- val playerRequest = backStackEntry.savedStateHandle.get<PlayerNavigationRequest>(PLAYER_REQUEST_KEY)
- ?: navController.previousBackStackEntry?.savedStateHandle?.get<PlayerNavigationRequest>(PLAYER_REQUEST_KEY)?.also {
- backStackEntry.savedStateHandle[PLAYER_REQUEST_KEY] = it
- }
+ val playerRequest = navigator.consumePlayerRequest(backStackEntry)
val safePlayerRequest = safePlayerNavigationRequest(playerRequest)
if (safePlayerRequest == null) {
LaunchedEffect(playerRequest) {
Log.w(APP_NAVIGATION_TAG, "Missing or invalid player request; returning to previous destination")
- if (!navController.popBackStack()) {
- navController.navigate(Routes.HOME) {
- popUpTo(Routes.PLAYER) { inclusive = true }
- launchSingleTop = true
- }
+ if (!navigator.execute(NavigationCommand.Back)) {
+ navigator.execute(
+ NavigationCommand.Navigate(
+ AppDestination.Home,
+ NavigationOptions(
+ launchSingleTop = true,
+ popUpTo = AppDestination.Player,
+ inclusive = true
+ )
+ )
+ )
}
}
} else {
@@ -406,35 +425,16 @@ internal fun AppNavigationGraph(
seasonNumber = safePlayerRequest.seasonNumber,
episodeNumber = safePlayerRequest.episodeNumber,
episodeId = safePlayerRequest.episodeId,
- onBack = {
- val route = safePlayerRequest.returnDestination?.let(AppRouteCodec::encode)
- if (!route.isNullOrBlank() && navController.popBackStack(route, false)) {
- // Popped back to the exact route already in the backstack (same VM, handoff works)
- Unit
- } else if (!route.isNullOrBlank()) {
- // Nothing left to pop — navigate to the return route or home as a last resort
- navController.navigate(route) {
- popUpTo(Routes.PLAYER) { inclusive = true }
- launchSingleTop = true
- restoreState = true
- }
- } else if (!navController.popBackStack()) {
- navController.navigate(Routes.HOME) {
- popUpTo(Routes.PLAYER) { inclusive = true }
- launchSingleTop = true
- restoreState = true
- }
- }
- // else: plain popBackStack() succeeded — returns to existing Guide entry, preserving EpgViewModel
- },
+ onBack = { navigator.returnTo(safePlayerRequest.returnDestination) },
onNavigate = { destination ->
- val route = AppRouteCodec.encode(destination)
- navController.navigateIfResumed(route) {
- launchSingleTop = true
- if (route == Routes.MULTI_VIEW) {
- popUpTo(Routes.PLAYER) { inclusive = true }
- }
- }
+ navigator.navigateIfResumed(
+ destination,
+ NavigationOptions(
+ launchSingleTop = true,
+ popUpTo = AppDestination.Player.takeIf { destination == AppDestination.MultiView },
+ inclusive = destination == AppDestination.MultiView
+ )
+ )
}
)
}
@@ -447,33 +447,22 @@ internal fun AppNavigationGraph(
navArgument("returnRoute") { type = NavType.StringType; defaultValue = "" }
)
) { backStackEntry ->
- val moviePresentationHint = backStackEntry.savedStateHandle.get<MovieDetailPresentationHint>(MOVIE_DETAIL_PRESENTATION_HINT_KEY)
- ?: navController.previousBackStackEntry?.savedStateHandle?.get<MovieDetailPresentationHint>(MOVIE_DETAIL_PRESENTATION_HINT_KEY)?.also {
- backStackEntry.savedStateHandle[MOVIE_DETAIL_PRESENTATION_HINT_KEY] = it
- }
+ navigator.consumeMoviePresentationHint(backStackEntry)
val returnRoute = backStackEntry.arguments?.getString("returnRoute").orEmpty().takeIf { it.isNotBlank() }
+ val returnDestination = returnRoute?.let(AppRouteCodec::decode)
val movieId = backStackEntry.arguments?.getLong("movieId") ?: -1L
com.streamvault.app.ui.screens.movies.MovieDetailScreen(
onPlay = { movie ->
- navController.navigateToPlayer(
+ navigator.openPlayer(
movie.toPlayerNavigationRequest(
returnDestination = AppDestination.MovieDetail(
movieId = movie.id.takeIf { it > 0L } ?: movieId,
- returnDestination = returnRoute?.let(AppRouteCodec::decode)
+ returnDestination = returnDestination
)
)
)
},
- onBack = {
- if (!returnRoute.isNullOrBlank()) {
- navController.navigate(returnRoute) {
- popUpTo(backStackEntry.destination.route ?: Routes.MOVIE_DETAIL) { inclusive = true }
- launchSingleTop = true
- }
- } else {
- navController.popBackStack()
- }
- }
+ onBack = { navigator.returnTo(returnDestination) }
)
}
@@ -484,39 +473,28 @@ internal fun AppNavigationGraph(
navArgument("returnRoute") { type = NavType.StringType; defaultValue = "" }
)
) { backStackEntry ->
- val seriesPresentationHint = backStackEntry.savedStateHandle.get<SeriesDetailPresentationHint>(SERIES_DETAIL_PRESENTATION_HINT_KEY)
- ?: navController.previousBackStackEntry?.savedStateHandle?.get<SeriesDetailPresentationHint>(SERIES_DETAIL_PRESENTATION_HINT_KEY)?.also {
- backStackEntry.savedStateHandle[SERIES_DETAIL_PRESENTATION_HINT_KEY] = it
- }
+ navigator.consumeSeriesPresentationHint(backStackEntry)
val returnRoute = backStackEntry.arguments?.getString("returnRoute").orEmpty().takeIf { it.isNotBlank() }
+ val returnDestination = returnRoute?.let(AppRouteCodec::decode)
val seriesId = backStackEntry.arguments?.getLong("seriesId") ?: -1L
com.streamvault.app.ui.screens.series.SeriesDetailScreen(
onEpisodeClick = { episode ->
- navController.navigateToPlayer(
+ navigator.openPlayer(
episode.toPlayerNavigationRequest(
returnDestination = AppDestination.SeriesDetail(
seriesId = episode.seriesId.takeIf { it > 0L } ?: seriesId,
- returnDestination = returnRoute?.let(AppRouteCodec::decode)
+ returnDestination = returnDestination
)
)
)
},
- onBack = {
- if (!returnRoute.isNullOrBlank()) {
- navController.navigate(returnRoute) {
- popUpTo(backStackEntry.destination.route ?: Routes.SERIES_DETAIL) { inclusive = true }
- launchSingleTop = true
- }
- } else {
- navController.popBackStack()
- }
- }
+ onBack = { navigator.returnTo(returnDestination) }
)
}
composable(Routes.MULTI_VIEW) {
MultiViewScreen(
- onBack = { navController.popBackStack() }
+ onBack = { navigator.back() }
)
}
}}
diff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigationLifecycle.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigationLifecycle.kt
new file mode 100644
index 00000000..ae99aff0
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/navigation/AppNavigationLifecycle.kt
@@ -0,0 +1,27 @@
+package com.streamvault.app.navigation
+
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import kotlin.coroutines.resume
+import kotlinx.coroutines.suspendCancellableCoroutine
+
+internal suspend fun Lifecycle.awaitResumed() {
+ if (currentState.isAtLeast(Lifecycle.State.RESUMED)) return
+ suspendCancellableCoroutine { continuation ->
+ lateinit var observer: LifecycleEventObserver
+ observer = LifecycleEventObserver { _, _ ->
+ when {
+ currentState.isAtLeast(Lifecycle.State.RESUMED) -> {
+ removeObserver(observer)
+ if (continuation.isActive) continuation.resume(Unit)
+ }
+ currentState == Lifecycle.State.DESTROYED -> {
+ removeObserver(observer)
+ continuation.cancel()
+ }
+ }
+ }
+ addObserver(observer)
+ continuation.invokeOnCancellation { removeObserver(observer) }
+ }
+}
diff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigationPayloads.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigationPayloads.kt
new file mode 100644
index 00000000..d177718b
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/navigation/AppNavigationPayloads.kt
@@ -0,0 +1,34 @@
+package com.streamvault.app.navigation
+
+import androidx.navigation.NavBackStackEntry
+import com.streamvault.core.navigation.PlayerNavigationRequest
+import com.streamvault.domain.model.Movie
+import com.streamvault.domain.model.MovieDetailPresentationHint
+import com.streamvault.domain.model.Series
+import com.streamvault.domain.model.SeriesDetailPresentationHint
+
+internal interface AppNavigationPayloads {
+ fun consumePlayerRequest(entry: NavBackStackEntry): PlayerNavigationRequest?
+ fun consumeMoviePresentationHint(entry: NavBackStackEntry): MovieDetailPresentationHint?
+ fun consumeSeriesPresentationHint(entry: NavBackStackEntry): SeriesDetailPresentationHint?
+}
+
+internal fun Movie.toMovieDetailPresentationHint(): MovieDetailPresentationHint? {
+ if (variants.isEmpty()) return null
+ return MovieDetailPresentationHint(
+ providerId = providerId,
+ logicalGroupId = logicalGroupId,
+ variants = variants,
+ duplicateConfidence = duplicateConfidence
+ )
+}
+
+internal fun Series.toSeriesDetailPresentationHint(): SeriesDetailPresentationHint? {
+ if (variants.isEmpty()) return null
+ return SeriesDetailPresentationHint(
+ providerId = providerId,
+ logicalGroupId = logicalGroupId,
+ variants = variants,
+ duplicateConfidence = duplicateConfidence
+ )
+}
diff --git a/app/src/main/java/com/streamvault/app/navigation/CatalogDetailNavigationActions.kt b/app/src/main/java/com/streamvault/app/navigation/CatalogDetailNavigationActions.kt
new file mode 100644
index 00000000..2ceb53a8
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/navigation/CatalogDetailNavigationActions.kt
@@ -0,0 +1,10 @@
+package com.streamvault.app.navigation
+
+import com.streamvault.core.navigation.AppDestination
+import com.streamvault.domain.model.Movie
+import com.streamvault.domain.model.Series
+
+internal interface CatalogDetailNavigationActions {
+ fun openMovieDetail(movie: Movie, returnDestination: AppDestination? = null)
+ fun openSeriesDetail(series: Series, returnDestination: AppDestination? = null)
+}
diff --git a/app/src/main/java/com/streamvault/app/navigation/NavControllerNavigator.kt b/app/src/main/java/com/streamvault/app/navigation/NavControllerNavigator.kt
new file mode 100644
index 00000000..2ae0553f
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/navigation/NavControllerNavigator.kt
@@ -0,0 +1,140 @@
+package com.streamvault.app.navigation
+
+import androidx.lifecycle.Lifecycle
+import androidx.navigation.NavBackStackEntry
+import androidx.navigation.NavHostController
+import androidx.navigation.NavOptionsBuilder
+import com.streamvault.core.navigation.AppDestination
+import com.streamvault.core.navigation.NavigationActions
+import com.streamvault.core.navigation.NavigationCommand
+import com.streamvault.core.navigation.NavigationOptions
+import com.streamvault.core.navigation.PlayerNavigationRequest
+import com.streamvault.domain.model.Movie
+import com.streamvault.domain.model.MovieDetailPresentationHint
+import com.streamvault.domain.model.Series
+import com.streamvault.domain.model.SeriesDetailPresentationHint
+
+internal class NavControllerNavigator(
+ private val navController: NavHostController
+) : NavigationActions, CatalogDetailNavigationActions, AppNavigationPayloads {
+
+ fun execute(command: NavigationCommand): Boolean = when (command) {
+ is NavigationCommand.Navigate -> navigateIfResumed(command.destination, command.options)
+ is NavigationCommand.OpenPlayer -> openPlayerIfResumed(command.request)
+ NavigationCommand.Back -> back()
+ is NavigationCommand.ReturnTo -> returnTo(command.destination)
+ }
+
+ override fun navigate(destination: AppDestination, options: NavigationOptions) {
+ navigateIfResumed(destination, options)
+ }
+
+ override fun openPlayer(request: PlayerNavigationRequest) {
+ openPlayerIfResumed(request)
+ }
+
+ override fun back(): Boolean = navController.popBackStack()
+
+ override fun returnTo(destination: AppDestination?): Boolean {
+ val route = destination?.let(AppRouteCodec::encode)
+ val hasReturnTarget = !route.isNullOrBlank()
+ val hasTargetInBackStack = hasReturnTarget && hasBackStackEntry(route!!)
+ return when (planReturnNavigation(hasReturnTarget, hasTargetInBackStack, navController.previousBackStackEntry != null)) {
+ ReturnNavigationPlan.PopToTarget -> navController.popBackStack(route!!, false)
+ ReturnNavigationPlan.NavigateToTarget -> navigateIfResumed(
+ destination!!,
+ NavigationOptions(
+ launchSingleTop = true,
+ restoreState = true,
+ popUpTo = AppDestination.Player,
+ inclusive = true
+ )
+ )
+ ReturnNavigationPlan.PopPrevious -> navController.popBackStack()
+ ReturnNavigationPlan.NavigateHome -> navigateIfResumed(
+ AppDestination.Home,
+ NavigationOptions(
+ launchSingleTop = true,
+ restoreState = true,
+ popUpTo = AppDestination.Player,
+ inclusive = true
+ )
+ )
+ }
+ }
+
+ internal fun navigateIfResumed(
+ destination: AppDestination,
+ options: NavigationOptions = NavigationOptions()
+ ): Boolean {
+ if (navController.currentBackStackEntry?.lifecycle?.currentState?.isAtLeast(Lifecycle.State.RESUMED) != true) {
+ return false
+ }
+ navController.navigate(AppRouteCodec.encode(destination)) {
+ apply(options)
+ }
+ return true
+ }
+
+ override fun openMovieDetail(movie: Movie, returnDestination: AppDestination?) {
+ if (!isResumed()) return
+ navController.currentBackStackEntry?.savedStateHandle?.set(
+ MOVIE_DETAIL_PRESENTATION_HINT_KEY,
+ movie.toMovieDetailPresentationHint()
+ )
+ navigateIfResumed(AppDestination.MovieDetail(movie.id, returnDestination))
+ }
+
+ override fun openSeriesDetail(series: Series, returnDestination: AppDestination?) {
+ if (!isResumed()) return
+ navController.currentBackStackEntry?.savedStateHandle?.set(
+ SERIES_DETAIL_PRESENTATION_HINT_KEY,
+ series.toSeriesDetailPresentationHint()
+ )
+ navigateIfResumed(AppDestination.SeriesDetail(series.id, returnDestination))
+ }
+
+ override fun consumePlayerRequest(entry: NavBackStackEntry): PlayerNavigationRequest? =
+ entry.savedStateHandle.get<PlayerNavigationRequest>(PLAYER_REQUEST_KEY)
+ ?: navController.previousBackStackEntry?.savedStateHandle
+ ?.get<PlayerNavigationRequest>(PLAYER_REQUEST_KEY)
+ ?.also { entry.savedStateHandle[PLAYER_REQUEST_KEY] = it }
+
+ override fun consumeMoviePresentationHint(entry: NavBackStackEntry): MovieDetailPresentationHint? =
+ entry.savedStateHandle.get<MovieDetailPresentationHint>(MOVIE_DETAIL_PRESENTATION_HINT_KEY)
+ ?: navController.previousBackStackEntry?.savedStateHandle
+ ?.get<MovieDetailPresentationHint>(MOVIE_DETAIL_PRESENTATION_HINT_KEY)
+ ?.also { entry.savedStateHandle[MOVIE_DETAIL_PRESENTATION_HINT_KEY] = it }
+
+ override fun consumeSeriesPresentationHint(entry: NavBackStackEntry): SeriesDetailPresentationHint? =
+ entry.savedStateHandle.get<SeriesDetailPresentationHint>(SERIES_DETAIL_PRESENTATION_HINT_KEY)
+ ?: navController.previousBackStackEntry?.savedStateHandle
+ ?.get<SeriesDetailPresentationHint>(SERIES_DETAIL_PRESENTATION_HINT_KEY)
+ ?.also { entry.savedStateHandle[SERIES_DETAIL_PRESENTATION_HINT_KEY] = it }
+
+ private fun openPlayerIfResumed(request: PlayerNavigationRequest): Boolean {
+ if (!isResumed()) return false
+ navController.currentBackStackEntry?.savedStateHandle?.set(PLAYER_REQUEST_KEY, request)
+ navController.navigate(AppRouteCodec.encode(AppDestination.Player)) {
+ launchSingleTop = true
+ }
+ return true
+ }
+
+ private fun hasBackStackEntry(route: String): Boolean =
+ runCatching { navController.getBackStackEntry(route) }.isSuccess
+
+ private fun isResumed(): Boolean =
+ navController.currentBackStackEntry?.lifecycle?.currentState?.isAtLeast(Lifecycle.State.RESUMED) == true
+
+ private fun NavOptionsBuilder.apply(options: NavigationOptions) {
+ launchSingleTop = options.launchSingleTop
+ restoreState = options.restoreState
+ options.popUpTo?.let { destination ->
+ popUpTo(AppRouteCodec.encode(destination)) {
+ inclusive = options.inclusive
+ saveState = options.saveState
+ }
+ }
+ }
+}
diff --git a/app/src/main/java/com/streamvault/app/navigation/ReturnNavigationPolicy.kt b/app/src/main/java/com/streamvault/app/navigation/ReturnNavigationPolicy.kt
new file mode 100644
index 00000000..e690c250
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/navigation/ReturnNavigationPolicy.kt
@@ -0,0 +1,19 @@
+package com.streamvault.app.navigation
+
+internal enum class ReturnNavigationPlan {
+ PopToTarget,
+ NavigateToTarget,
+ PopPrevious,
+ NavigateHome
+}
+
+internal fun planReturnNavigation(
+ hasReturnTarget: Boolean,
+ hasTargetInBackStack: Boolean,
+ hasPreviousEntry: Boolean
+): ReturnNavigationPlan = when {
+ hasReturnTarget && hasTargetInBackStack -> ReturnNavigationPlan.PopToTarget
+ hasReturnTarget -> ReturnNavigationPlan.NavigateToTarget
+ hasPreviousEntry -> ReturnNavigationPlan.PopPrevious
+ else -> ReturnNavigationPlan.NavigateHome
+}
diff --git a/app/src/test/java/com/streamvault/app/navigation/ReturnNavigationPolicyTest.kt b/app/src/test/java/com/streamvault/app/navigation/ReturnNavigationPolicyTest.kt
new file mode 100644
index 00000000..d3520f8b
--- /dev/null
+++ b/app/src/test/java/com/streamvault/app/navigation/ReturnNavigationPolicyTest.kt
@@ -0,0 +1,39 @@
+package com.streamvault.app.navigation
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class ReturnNavigationPolicyTest {
+ @Test
+ fun existingTargetPopsBeforeNavigating() {
+ assertThat(
+ planReturnNavigation(
+ hasReturnTarget = true,
+ hasTargetInBackStack = true,
+ hasPreviousEntry = true
+ )
+ ).isEqualTo(ReturnNavigationPlan.PopToTarget)
+ }
+
+ @Test
+ fun missingTargetNavigatesAndClearsPlayer() {
+ assertThat(
+ planReturnNavigation(
+ hasReturnTarget = true,
+ hasTargetInBackStack = false,
+ hasPreviousEntry = true
+ )
+ ).isEqualTo(ReturnNavigationPlan.NavigateToTarget)
+ }
+
+ @Test
+ fun missingReturnAndBackStackFallsBackHome() {
+ assertThat(
+ planReturnNavigation(
+ hasReturnTarget = false,
+ hasTargetInBackStack = false,
+ hasPreviousEntry = false
+ )
+ ).isEqualTo(ReturnNavigationPlan.NavigateHome)
+ }
+}