StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
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.ktindex 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.rememberNavControllerimport androidx.navigation.navArgumentimport com.streamvault.app.ui.model.isArchivePlayableimport com.streamvault.core.navigation.PlayerNavigationRequest+import com.streamvault.core.navigation.NavigationCommand+import com.streamvault.core.navigation.NavigationOptions+import com.streamvault.core.navigation.AppDestinationimport com.streamvault.domain.model.Channelimport com.streamvault.domain.model.Episodeimport com.streamvault.domain.model.Movie@@ -60,6 +63,7 @@ import kotlinx.coroutines.suspendCancellableCoroutine@Composablefun AppNavigation(mainActivity: MainActivity) {val navController = rememberNavController()+ val navigator = remember(navController) { NavControllerNavigator(navController) }val currentBackStackEntry = navController.currentBackStackEntryAsState().valueval 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?.routeif (route != Routes.LIVE_TV_DESTINATION && route != Routes.LIVE_TV) return@LaunchedEffectentry.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.ktindex 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.MainActivityimport com.streamvault.domain.model.AppLandingDestinationimport 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.PLUGINSAppTopLevelDestination.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.ktindex 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.navigationimport androidx.compose.runtime.Composableimport androidx.compose.runtime.LaunchedEffectimport 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@Composableinternal 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.ktindex 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.navArgumentimport com.streamvault.app.ui.model.isArchivePlayableimport com.streamvault.core.navigation.PlayerNavigationRequestimport com.streamvault.core.navigation.AppDestination+import com.streamvault.core.navigation.NavigationOptions+import com.streamvault.core.navigation.NavigationCommandimport com.streamvault.domain.model.Channelimport com.streamvault.domain.model.Episodeimport com.streamvault.domain.model.Movie@@ -45,10 +47,8 @@ import com.streamvault.domain.model.AppLandingDestinationimport com.streamvault.domain.model.AppTopLevelDestinationimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.CatalogLayout-import com.streamvault.domain.model.MovieDetailPresentationHintimport com.streamvault.domain.model.ActiveLiveSourceimport com.streamvault.domain.model.Series-import com.streamvault.domain.model.SeriesDetailPresentationHintimport com.streamvault.domain.model.VirtualCategoryIdsimport java.io.Serializableimport kotlin.coroutines.resume@@ -60,6 +60,7 @@ import kotlinx.coroutines.suspendCancellableCoroutine@Composableinternal 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") ?: -1Lcom.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") ?: -1Lcom.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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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.ktnew file mode 100644index 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)+ }+}