Skip to content

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

refactor: coordinate typed app navigation

David Nashash56682962adfe
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 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.kt
new file mode 100644
index 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.kt
index 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.resolveAppLocale
import com.streamvault.app.navigation.AppNavigation
import com.streamvault.app.navigation.AppNavigationCoordinator
import com.streamvault.app.navigation.ExternalNavigationRequestParser
-import com.streamvault.app.navigation.StartupNavigationResolver
import com.streamvault.core.navigation.PlayerNavigationRequest
import com.streamvault.core.navigation.ExternalNavigationRequest
import com.streamvault.core.ui.theme.StreamVaultTheme
import 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.PlaybackHistoryRepository
import com.streamvault.domain.repository.ProviderRepository
import dagger.hilt.android.AndroidEntryPoint
@@ -73,18 +68,6 @@ class MainActivity : ComponentActivity() {
@Inject
lateinit var preferencesRepository: PreferencesRepository
- @Inject
- lateinit var combinedM3uRepository: CombinedM3uRepository
-
- @Inject
- lateinit var favoriteRepository: FavoriteRepository
-
- @Inject
- lateinit var playbackHistoryRepository: PlaybackHistoryRepository
-
- @Inject
- lateinit var channelRepository: ChannelRepository
-
@Inject
lateinit var providerRepository: ProviderRepository
@@ -102,11 +85,6 @@ class MainActivity : ComponentActivity() {
@Inject
lateinit 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.kt
index 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.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.NavBackStackEntry
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.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
-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@LaunchedEffect
val 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.id
entry.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@LaunchedEffect
entry.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.kt
index 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.navigation
import com.streamvault.core.navigation.AppDestination
-import com.streamvault.domain.model.AppLandingDestination
import com.streamvault.domain.model.CatalogLayout
import 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.Movies
else -> 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)
- )
-} ?: requestedRoute
diff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigationStartupPolicy.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigationStartupPolicy.kt
deleted file mode 100644
index 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)
- .playerRequest
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 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
# Navigation
navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigation-compose" }
+navigation-testing = { group = "androidx.navigation", name = "navigation-testing", version.ref = "navigation-compose" }
# Coroutines
coroutines-core = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-core", version.ref = "coroutines" }