Skip to content

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

refactor: extract external navigation coordination

David Nashash99ff95086341
diff --git a/app/src/androidTest/java/com/streamvault/app/compat/PlatformCompatibilityMatrixTest.kt b/app/src/androidTest/java/com/streamvault/app/compat/PlatformCompatibilityMatrixTest.kt
index 19f34216..3a7da700 100644
--- a/app/src/androidTest/java/com/streamvault/app/compat/PlatformCompatibilityMatrixTest.kt
+++ b/app/src/androidTest/java/com/streamvault/app/compat/PlatformCompatibilityMatrixTest.kt
@@ -4,7 +4,8 @@ import android.os.Build
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import com.google.common.truth.Truth.assertThat
-import com.streamvault.app.navigation.ExternalDestination
+import com.streamvault.app.navigation.AppRouteCodec
+import com.streamvault.core.navigation.AppDestination
import com.streamvault.app.service.DownloadServiceStartMode
import com.streamvault.app.service.resolveDownloadServiceStartMode
import java.net.URLEncoder
@@ -33,40 +34,40 @@ class PlatformCompatibilityMatrixTest {
@Test
fun legacyRouteParsingKeepsEncodedUtf8ValuesOnEverySupportedApi() {
val encodedImport = URLEncoder.encode("https://fixture.invalid/playlist?name=Ειδήσεις", StandardCharsets.UTF_8.name())
- val destination = ExternalDestination.fromLegacyRoute(
+ val destination = AppRouteCodec.decodeLegacyExternalRoute(
"provider_setup?providerId=7&importUri=$encodedImport"
)
assertThat(destination).isEqualTo(
- ExternalDestination.ProviderSetup(
+ AppDestination.ProviderSetup(
providerId = 7L,
importUri = "https://fixture.invalid/playlist?name=Ειδήσεις"
)
)
assertThat(
- ExternalDestination.fromLegacyRoute("provider_setup?importUri=%not-a-valid-escape")
- ).isEqualTo(ExternalDestination.ProviderSetup())
+ AppRouteCodec.decodeLegacyExternalRoute("provider_setup?importUri=%not-a-valid-escape")
+ ).isEqualTo(AppDestination.ProviderSetup())
}
@Test
fun encodedReturnRouteAndRepeatedParametersRemainSafe() {
assertThat(
- ExternalDestination.fromLegacyRoute(
- "movie_detail/42?returnRoute=live_tv%3Fcategory%3Dnews%2520east"
+ AppRouteCodec.decodeLegacyExternalRoute(
+ "movie_detail/42?returnRoute=live_tv%3FcategoryId%3D7"
)
).isEqualTo(
- ExternalDestination.MovieDetail(
+ AppDestination.MovieDetail(
movieId = 42L,
- returnRoute = "live_tv?category=news%20east"
+ returnDestination = AppDestination.LiveTv(7L)
)
)
assertThat(
- ExternalDestination.fromLegacyRoute(
+ AppRouteCodec.decodeLegacyExternalRoute(
"movie_detail/42?returnRoute=live_tv&returnRoute=home"
)
).isEqualTo(
- ExternalDestination.MovieDetail(movieId = 42L, returnRoute = "home")
+ AppDestination.MovieDetail(movieId = 42L, returnDestination = AppDestination.Home)
)
}
diff --git a/app/src/main/java/com/streamvault/app/MainActivity.kt b/app/src/main/java/com/streamvault/app/MainActivity.kt
index dcec8f9e..ac719125 100644
--- a/app/src/main/java/com/streamvault/app/MainActivity.kt
+++ b/app/src/main/java/com/streamvault/app/MainActivity.kt
@@ -1,6 +1,5 @@
package com.streamvault.app
-import android.app.SearchManager
import android.content.Intent
import android.content.pm.PackageManager
import android.os.Bundle
@@ -9,16 +8,17 @@ import android.os.StrictMode
import android.util.Rational
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
+import androidx.activity.viewModels
import androidx.core.view.doOnPreDraw
import com.streamvault.app.cast.CastManager
import com.streamvault.app.cast.CastRouteChooserActivity
-import com.streamvault.app.backup.BackupFileBridge
import com.streamvault.app.device.isTelevisionDevice
import com.streamvault.app.localization.resolveAppLocale
import com.streamvault.app.navigation.AppNavigation
-import com.streamvault.app.navigation.ExternalDestination
-import com.streamvault.app.navigation.ExternalNavigationRequest
+import com.streamvault.app.navigation.AppNavigationCoordinator
+import com.streamvault.app.navigation.ExternalNavigationRequestParser
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
@@ -46,10 +46,8 @@ import androidx.core.view.WindowInsetsControllerCompat
import java.util.Locale
import android.content.Context
import android.content.ContextWrapper
-import android.net.Uri
import android.content.res.AssetManager
import android.content.res.Resources
-import android.speech.RecognizerIntent
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
@@ -98,9 +96,12 @@ class MainActivity : ComponentActivity() {
private val _pictureInPictureModeFlow = MutableStateFlow(false)
val pictureInPictureModeFlow: StateFlow<Boolean> = _pictureInPictureModeFlow.asStateFlow()
- private val _externalNavigationRequestFlow = MutableStateFlow<ExternalNavigationRequest?>(null)
- val externalNavigationRequestFlow: StateFlow<ExternalNavigationRequest?> =
- _externalNavigationRequestFlow.asStateFlow()
+ private val appNavigationCoordinator: AppNavigationCoordinator by viewModels()
+
+ @Inject
+ lateinit var externalNavigationRequestParser: ExternalNavigationRequestParser
+
+ internal val pendingNavigationCommand = appNavigationCoordinator.pendingCommand
private var playerPictureInPictureState = PlayerPictureInPictureState()
@@ -235,12 +236,14 @@ class MainActivity : ComponentActivity() {
applyPlayerPictureInPictureParams()
}
- fun clearExternalNavigationRequest() {
- _externalNavigationRequestFlow.value = null
+ internal fun acknowledgeNavigationCommand(id: Long) {
+ appNavigationCoordinator.acknowledge(id)
}
fun openPlayer(request: PlayerNavigationRequest) {
- _externalNavigationRequestFlow.value = ExternalNavigationRequest.Player(request)
+ appNavigationCoordinator.submitExternalRequest(
+ ExternalNavigationRequest.Player(request)
+ )
}
fun enterPlayerPictureInPictureModeFromPlayer(): Boolean {
@@ -335,112 +338,7 @@ class MainActivity : ComponentActivity() {
}
private fun handleExternalIntent(intent: Intent?) {
- val request = intent?.toExternalNavigationRequest() ?: return
- _externalNavigationRequestFlow.value = request
- }
-
- private fun Intent.toExternalNavigationRequest(): ExternalNavigationRequest? {
- readPlayerRequestExtra()?.let { return ExternalNavigationRequest.Player(it) }
- readExternalDestinationExtra()?.let { return ExternalNavigationRequest.Destination(it) }
- getStringExtra(EXTRA_EXTERNAL_ROUTE)
- ?.let(ExternalDestination::fromLegacyRoute)
- ?.let { return ExternalNavigationRequest.Destination(it) }
- if (hasExtra(EXTRA_EXTERNAL_ROUTE)) {
- return ExternalNavigationRequest.Destination(ExternalDestination.Home)
- }
- readImportedPlaylistUri()?.let { return ExternalNavigationRequest.ImportM3u(it) }
- readImportedBackupUri()?.let { return ExternalNavigationRequest.ImportBackup(it) }
-
- val query = when (action) {
- Intent.ACTION_SEARCH,
- Intent.ACTION_ASSIST,
- RecognizerIntent.ACTION_VOICE_SEARCH_HANDS_FREE -> {
- getStringExtra(SearchManager.QUERY)
- ?: getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS)?.firstOrNull()
- }
-
- else -> null
- }?.trim().orEmpty()
-
- query.takeIf { it.isNotBlank() }?.let(ExternalNavigationRequest::Search)?.let { return it }
-
- return if (action == Intent.ACTION_VIEW) {
- ExternalNavigationRequest.Destination(ExternalDestination.Home)
- } else {
- null
- }
- }
-
- private fun Intent.readImportedPlaylistUri(): String? {
- if (action != Intent.ACTION_VIEW) return null
- val targetUri = data ?: return null
- val normalizedPath = targetUri.toString().substringBefore('?').lowercase(Locale.ROOT)
- val mimeType = type?.lowercase(Locale.ROOT).orEmpty()
- val isPlaylistMime = mimeType in setOf(
- "audio/x-mpegurl",
- "audio/mpegurl",
- "application/x-mpegurl",
- "application/vnd.apple.mpegurl",
- "application/mpegurl"
- )
- val isPlaylistPath = normalizedPath.endsWith(".m3u") || normalizedPath.endsWith(".m3u8")
- if (!isPlaylistMime && !isPlaylistPath) return null
- return when (targetUri.scheme?.lowercase(Locale.ROOT)) {
- "content", "file" -> targetUri.toString()
- else -> null
- }
- }
-
- private fun Intent.readImportedBackupUri(): String? {
- val targetUri = when (action) {
- Intent.ACTION_VIEW -> data
- Intent.ACTION_SEND -> readStreamUriExtra()
- else -> null
- } ?: return null
- if (!isBackupJsonCandidate(targetUri)) return null
- return BackupFileBridge.copyToImportInbox(this@MainActivity, targetUri)?.toString()
- ?: targetUri.toString()
- }
-
- @Suppress("DEPRECATION")
- private fun Intent.readStreamUriExtra(): Uri? {
- return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
- getParcelableExtra(Intent.EXTRA_STREAM, Uri::class.java)
- } else {
- getParcelableExtra(Intent.EXTRA_STREAM) as? Uri
- } ?: clipData?.takeIf { it.itemCount > 0 }?.getItemAt(0)?.uri
- }
-
- private fun Intent.isBackupJsonCandidate(uri: Uri): Boolean {
- val normalizedPath = uri.toString().substringBefore('?').lowercase(Locale.ROOT)
- val mimeType = type?.lowercase(Locale.ROOT).orEmpty()
- val isJsonMime = mimeType in setOf(
- "application/json",
- "text/json",
- "application/x-json",
- "application/octet-stream",
- "text/plain",
- )
- val isJsonPath = normalizedPath.endsWith(".json")
- if (!isJsonMime && !isJsonPath) return false
- return uri.scheme?.lowercase(Locale.ROOT) in setOf("content", "file")
- }
-
- @Suppress("DEPRECATION")
- private fun Intent.readPlayerRequestExtra(): PlayerNavigationRequest? {
- return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
- getSerializableExtra(EXTRA_PLAYER_REQUEST, PlayerNavigationRequest::class.java)
- } else {
- getSerializableExtra(EXTRA_PLAYER_REQUEST) as? PlayerNavigationRequest
- }
- }
-
- @Suppress("DEPRECATION")
- private fun Intent.readExternalDestinationExtra(): ExternalDestination? {
- return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
- getSerializableExtra(EXTRA_EXTERNAL_DESTINATION, ExternalDestination::class.java)
- } else {
- getSerializableExtra(EXTRA_EXTERNAL_DESTINATION) as? ExternalDestination
- }
+ intent?.let(externalNavigationRequestParser::parse)
+ ?.let(appNavigationCoordinator::submitExternalRequest)
}
}
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 d60d0025..9ca8078e 100644
--- a/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt
+++ b/app/src/main/java/com/streamvault/app/navigation/AppNavigation.kt
@@ -79,7 +79,7 @@ fun AppNavigation(mainActivity: MainActivity) {
.first()
loadedSplitPreferenceProviderId = providerId
}
- val externalNavigationRequest = mainActivity.externalNavigationRequestFlow.collectAsStateWithLifecycle().value
+ val pendingNavigationCommand = mainActivity.pendingNavigationCommand.collectAsStateWithLifecycle().value
val topLevelDestinations = mainActivity.preferencesRepository.appTopLevelDestinations
.collectAsStateWithLifecycle(initialValue = AppTopLevelDestination.defaultOrder)
.value
@@ -140,12 +140,14 @@ fun AppNavigation(mainActivity: MainActivity) {
}
}
- ExternalNavigationHost(
- request = externalNavigationRequest,
- currentBackStackEntry = currentBackStackEntry,
- navigator = navigator,
- onRequestHandled = mainActivity::clearExternalNavigationRequest
- )
+ LaunchedEffect(pendingNavigationCommand, currentBackStackEntry) {
+ val pending = pendingNavigationCommand ?: return@LaunchedEffect
+ 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.
diff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigationCoordinator.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigationCoordinator.kt
new file mode 100644
index 00000000..6f41afe5
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/navigation/AppNavigationCoordinator.kt
@@ -0,0 +1,75 @@
+package com.streamvault.app.navigation
+
+import androidx.lifecycle.ViewModel
+import com.streamvault.core.navigation.AppDestination
+import com.streamvault.core.navigation.ExternalNavigationRequest
+import com.streamvault.core.navigation.NavigationCommand
+import com.streamvault.core.navigation.NavigationOptions
+import com.streamvault.core.navigation.PlayerNavigationRequest
+import dagger.hilt.android.lifecycle.HiltViewModel
+import java.util.concurrent.atomic.AtomicLong
+import javax.inject.Inject
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+data class PendingNavigationCommand(
+ val id: Long,
+ val command: NavigationCommand
+)
+
+@HiltViewModel
+class AppNavigationCoordinator @Inject constructor(
+ private val commandIds: NavigationCommandIdSource
+) : ViewModel() {
+ private val commandQueue = ArrayDeque<PendingNavigationCommand>()
+ private val _pendingCommand = MutableStateFlow<PendingNavigationCommand?>(null)
+ val pendingCommand: StateFlow<PendingNavigationCommand?> = _pendingCommand.asStateFlow()
+
+ fun submitExternalRequest(request: ExternalNavigationRequest) {
+ submit(request.toNavigationCommand())
+ }
+
+ fun submit(command: NavigationCommand) {
+ commandQueue += PendingNavigationCommand(commandIds.next(), command)
+ if (_pendingCommand.value == null) {
+ _pendingCommand.value = commandQueue.first()
+ }
+ }
+
+ fun acknowledge(id: Long) {
+ val pending = commandQueue.firstOrNull() ?: return
+ if (pending.id != id) return
+ commandQueue.removeFirst()
+ _pendingCommand.value = commandQueue.firstOrNull()
+ }
+}
+
+internal fun ExternalNavigationRequest.toNavigationCommand(): NavigationCommand = when (this) {
+ is ExternalNavigationRequest.Search -> NavigationCommand.Navigate(
+ destination = AppDestination.Search(query),
+ options = NavigationOptions(launchSingleTop = true)
+ )
+ is ExternalNavigationRequest.Player -> NavigationCommand.OpenPlayer(request)
+ is ExternalNavigationRequest.Destination -> NavigationCommand.Navigate(
+ destination = destination,
+ options = NavigationOptions(launchSingleTop = true)
+ )
+ is ExternalNavigationRequest.ImportM3u -> NavigationCommand.Navigate(
+ destination = AppDestination.ProviderSetup(importUri = uri),
+ options = NavigationOptions(launchSingleTop = true)
+ )
+ is ExternalNavigationRequest.ImportBackup -> NavigationCommand.Navigate(
+ destination = AppDestination.Settings(backupUri = uri),
+ options = NavigationOptions(launchSingleTop = true)
+ )
+}
+
+fun interface NavigationCommandIdSource {
+ fun next(): Long
+}
+
+internal class AtomicNavigationCommandIdSource @Inject constructor() : NavigationCommandIdSource {
+ private val nextId = AtomicLong(0L)
+ override fun next(): Long = nextId.incrementAndGet()
+}
diff --git a/app/src/main/java/com/streamvault/app/navigation/AppNavigationExternalNavigation.kt b/app/src/main/java/com/streamvault/app/navigation/AppNavigationExternalNavigation.kt
deleted file mode 100644
index e2db2afd..00000000
--- a/app/src/main/java/com/streamvault/app/navigation/AppNavigationExternalNavigation.kt
+++ /dev/null
@@ -1,65 +0,0 @@
-package com.streamvault.app.navigation
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.navigation.NavBackStackEntry
-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?,
- navigator: NavControllerNavigator,
- onRequestHandled: () -> Unit
-) {
- LaunchedEffect(request, currentBackStackEntry) {
- val entry = currentBackStackEntry ?: return@LaunchedEffect
- entry.lifecycle.awaitResumed()
- when (request) {
- is ExternalNavigationRequest.Player -> {
- if (navigator.execute(NavigationCommand.OpenPlayer(request.request))) {
- onRequestHandled()
- }
- }
-
- is ExternalNavigationRequest.Destination -> {
- val destination = AppRouteCodec.decode(request.destination.toRoute())
- ?: AppDestination.Home
- if (navigator.execute(NavigationCommand.Navigate(destination, NavigationOptions(launchSingleTop = true)))) {
- onRequestHandled()
- }
- }
-
- is ExternalNavigationRequest.ImportM3u -> {
- if (navigator.execute(NavigationCommand.Navigate(
- AppDestination.ProviderSetup(importUri = request.uri),
- NavigationOptions(launchSingleTop = true)
- ))) {
- onRequestHandled()
- }
- }
-
- is ExternalNavigationRequest.ImportBackup -> {
- if (navigator.execute(NavigationCommand.Navigate(
- AppDestination.Settings(backupUri = request.uri),
- NavigationOptions(launchSingleTop = true)
- ))) {
- onRequestHandled()
- }
- }
-
- is ExternalNavigationRequest.Search -> {
- if (navigator.execute(NavigationCommand.Navigate(
- AppDestination.Search(request.query),
- NavigationOptions(launchSingleTop = true)
- ))) {
- onRequestHandled()
- }
- }
-
- null -> Unit
- }
- }
-}
diff --git a/app/src/main/java/com/streamvault/app/navigation/ExternalNavigationRequest.kt b/app/src/main/java/com/streamvault/app/navigation/ExternalNavigationRequest.kt
deleted file mode 100644
index b79472ba..00000000
--- a/app/src/main/java/com/streamvault/app/navigation/ExternalNavigationRequest.kt
+++ /dev/null
@@ -1,102 +0,0 @@
-package com.streamvault.app.navigation
-
-import com.streamvault.core.navigation.PlayerNavigationRequest
-import java.io.Serializable
-import java.net.URLDecoder
-
-sealed class ExternalDestination : Serializable {
- data object Home : ExternalDestination()
- data object Plugins : ExternalDestination()
-
- data class ProviderSetup(
- val providerId: Long? = null,
- val importUri: String? = null
- ) : ExternalDestination()
-
- data class MovieDetail(
- val movieId: Long,
- val returnRoute: String? = null
- ) : ExternalDestination()
-
- data class SeriesDetail(
- val seriesId: Long,
- val returnRoute: String? = null
- ) : ExternalDestination()
-
- fun toRoute(): String = when (this) {
- Home -> Routes.HOME
- Plugins -> Routes.PLUGINS
- is ProviderSetup -> Routes.providerSetup(providerId = providerId, importUri = importUri)
- is MovieDetail -> Routes.movieDetail(movieId = movieId, returnRoute = returnRoute)
- is SeriesDetail -> Routes.seriesDetail(seriesId = seriesId, returnRoute = returnRoute)
- }
-
- companion object {
- fun fromLegacyRoute(route: String): ExternalDestination? {
- val normalizedRoute = route.trim()
- if (normalizedRoute.isEmpty()) return null
-
- return when {
- normalizedRoute == Routes.HOME -> Home
- normalizedRoute == Routes.PLUGINS -> Plugins
- normalizedRoute.startsWith(Routes.PROVIDER_SETUP.substringBefore('?')) -> {
- val queryParameters = normalizedRoute.queryParameters()
- val providerId = queryParameters["providerId"]
- ?.toLongOrNull()
- ?.takeIf { it >= 0L }
- val importUri = queryParameters["importUri"]
- ?.takeIf { it.isNotBlank() }
- ProviderSetup(providerId = providerId, importUri = importUri)
- }
-
- normalizedRoute.startsWith("movie_detail/") -> {
- val pathSegments = normalizedRoute.pathSegments()
- val movieId = pathSegments.getOrNull(1)?.toLongOrNull() ?: return null
- MovieDetail(
- movieId = movieId,
- returnRoute = normalizedRoute.queryParameters()["returnRoute"]
- ?.takeIf { it.isNotBlank() }
- )
- }
-
- normalizedRoute.startsWith("series_detail/") -> {
- val pathSegments = normalizedRoute.pathSegments()
- val seriesId = pathSegments.getOrNull(1)?.toLongOrNull() ?: return null
- SeriesDetail(
- seriesId = seriesId,
- returnRoute = normalizedRoute.queryParameters()["returnRoute"]
- ?.takeIf { it.isNotBlank() }
- )
- }
-
- else -> null
- }
- }
- }
-}
-
-private fun String.pathSegments(): List<String> = substringBefore('?').split('/').filter { it.isNotBlank() }
-
-private fun String.queryParameters(): Map<String, String> {
- val query = substringAfter('?', missingDelimiterValue = "")
- if (query.isBlank()) return emptyMap()
- return query.split('&')
- .mapNotNull { entry ->
- val key = entry.substringBefore('=', missingDelimiterValue = "").takeIf { it.isNotBlank() }
- ?: return@mapNotNull null
- val rawValue = entry.substringAfter('=', missingDelimiterValue = "")
- val value = runCatching { URLDecoder.decode(rawValue, Charsets.UTF_8.name()) }
- .getOrNull()
- ?: return@mapNotNull null
- key to value
- }
- .toMap()
-}
-
-sealed interface ExternalNavigationRequest {
- data class Search(val query: String) : ExternalNavigationRequest
- data class Player(val request: PlayerNavigationRequest) : ExternalNavigationRequest
- data class Destination(val destination: ExternalDestination) : ExternalNavigationRequest
- data class ImportM3u(val uri: String) : ExternalNavigationRequest
- data class ImportBackup(val uri: String) : ExternalNavigationRequest
-}
diff --git a/app/src/main/java/com/streamvault/app/navigation/ExternalNavigationRequestParser.kt b/app/src/main/java/com/streamvault/app/navigation/ExternalNavigationRequestParser.kt
new file mode 100644
index 00000000..8bdd92c6
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/navigation/ExternalNavigationRequestParser.kt
@@ -0,0 +1,127 @@
+package com.streamvault.app.navigation
+
+import android.app.SearchManager
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.speech.RecognizerIntent
+import com.streamvault.app.MainActivity
+import com.streamvault.app.backup.BackupFileBridge
+import com.streamvault.core.navigation.AppDestination
+import com.streamvault.core.navigation.ExternalNavigationRequest
+import com.streamvault.core.navigation.PlayerNavigationRequest
+import dagger.hilt.android.qualifiers.ApplicationContext
+import java.util.Locale
+import javax.inject.Inject
+
+class ExternalNavigationRequestParser @Inject constructor(
+ @ApplicationContext private val context: Context
+) {
+ fun parse(intent: Intent): ExternalNavigationRequest? {
+ readPlayerRequestExtra(intent)?.let { return ExternalNavigationRequest.Player(it) }
+ readExternalDestinationExtra(intent)?.let { return ExternalNavigationRequest.Destination(it) }
+
+ intent.getStringExtra(MainActivity.EXTRA_EXTERNAL_ROUTE)
+ ?.let(AppRouteCodec::decodeLegacyExternalRoute)
+ ?.let { return ExternalNavigationRequest.Destination(it) }
+ if (intent.hasExtra(MainActivity.EXTRA_EXTERNAL_ROUTE)) {
+ return ExternalNavigationRequest.Destination(AppDestination.Home)
+ }
+
+ readImportedPlaylistUri(intent)?.let { return ExternalNavigationRequest.ImportM3u(it) }
+ readImportedBackupUri(intent)?.let { return ExternalNavigationRequest.ImportBackup(it) }
+
+ val query = when (intent.action) {
+ Intent.ACTION_SEARCH,
+ Intent.ACTION_ASSIST,
+ RecognizerIntent.ACTION_VOICE_SEARCH_HANDS_FREE -> {
+ intent.getStringExtra(SearchManager.QUERY)
+ ?: intent.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS)?.firstOrNull()
+ }
+ else -> null
+ }?.trim().orEmpty()
+ query.takeIf(String::isNotBlank)?.let { return ExternalNavigationRequest.Search(it) }
+
+ return if (intent.action == Intent.ACTION_VIEW) {
+ ExternalNavigationRequest.Destination(AppDestination.Home)
+ } else {
+ null
+ }
+ }
+
+ private fun readImportedPlaylistUri(intent: Intent): String? {
+ if (intent.action != Intent.ACTION_VIEW) return null
+ val targetUri = intent.data ?: return null
+ val normalizedPath = targetUri.toString().substringBefore('?').lowercase(Locale.ROOT)
+ val mimeType = intent.type?.lowercase(Locale.ROOT).orEmpty()
+ val isPlaylistMime = mimeType in setOf(
+ "audio/x-mpegurl",
+ "audio/mpegurl",
+ "application/x-mpegurl",
+ "application/vnd.apple.mpegurl",
+ "application/mpegurl"
+ )
+ val isPlaylistPath = normalizedPath.endsWith(".m3u") || normalizedPath.endsWith(".m3u8")
+ if (!isPlaylistMime && !isPlaylistPath) return null
+ return targetUri.toString().takeIf {
+ targetUri.scheme?.lowercase(Locale.ROOT) in setOf("content", "file")
+ }
+ }
+
+ private fun readImportedBackupUri(intent: Intent): String? {
+ val targetUri = when (intent.action) {
+ Intent.ACTION_VIEW -> intent.data
+ Intent.ACTION_SEND -> readStreamUriExtra(intent)
+ else -> null
+ } ?: return null
+ if (!isBackupJsonCandidate(intent, targetUri)) return null
+ return BackupFileBridge.copyToImportInbox(context, targetUri)?.toString()
+ ?: targetUri.toString()
+ }
+
+ @Suppress("DEPRECATION")
+ private fun readStreamUriExtra(intent: Intent): Uri? =
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ intent.getParcelableExtra(Intent.EXTRA_STREAM, Uri::class.java)
+ } else {
+ intent.getParcelableExtra(Intent.EXTRA_STREAM) as? Uri
+ } ?: intent.clipData?.takeIf { it.itemCount > 0 }?.getItemAt(0)?.uri
+
+ private fun isBackupJsonCandidate(intent: Intent, uri: Uri): Boolean {
+ val normalizedPath = uri.toString().substringBefore('?').lowercase(Locale.ROOT)
+ val mimeType = intent.type?.lowercase(Locale.ROOT).orEmpty()
+ val isJsonMime = mimeType in setOf(
+ "application/json",
+ "text/json",
+ "application/x-json",
+ "application/octet-stream",
+ "text/plain"
+ )
+ val isJsonPath = normalizedPath.endsWith(".json")
+ if (!isJsonMime && !isJsonPath) return false
+ return uri.scheme?.lowercase(Locale.ROOT) in setOf("content", "file")
+ }
+
+ @Suppress("DEPRECATION")
+ private fun readPlayerRequestExtra(intent: Intent): PlayerNavigationRequest? =
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ intent.getSerializableExtra(
+ MainActivity.EXTRA_PLAYER_REQUEST,
+ PlayerNavigationRequest::class.java
+ )
+ } else {
+ intent.getSerializableExtra(MainActivity.EXTRA_PLAYER_REQUEST) as? PlayerNavigationRequest
+ }
+
+ @Suppress("DEPRECATION")
+ private fun readExternalDestinationExtra(intent: Intent): AppDestination? =
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+ intent.getSerializableExtra(
+ MainActivity.EXTRA_EXTERNAL_DESTINATION,
+ AppDestination::class.java
+ )
+ } else {
+ intent.getSerializableExtra(MainActivity.EXTRA_EXTERNAL_DESTINATION) as? AppDestination
+ }
+}
diff --git a/app/src/main/java/com/streamvault/app/navigation/NavigationCoordinatorModule.kt b/app/src/main/java/com/streamvault/app/navigation/NavigationCoordinatorModule.kt
new file mode 100644
index 00000000..88274474
--- /dev/null
+++ b/app/src/main/java/com/streamvault/app/navigation/NavigationCoordinatorModule.kt
@@ -0,0 +1,17 @@
+package com.streamvault.app.navigation
+
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.android.components.ActivityRetainedComponent
+import dagger.hilt.android.scopes.ActivityRetainedScoped
+
+@Module
+@InstallIn(ActivityRetainedComponent::class)
+internal abstract class NavigationCoordinatorModule {
+ @Binds
+ @ActivityRetainedScoped
+ abstract fun bindNavigationCommandIdSource(
+ implementation: AtomicNavigationCommandIdSource
+ ): NavigationCommandIdSource
+}
diff --git a/app/src/main/java/com/streamvault/app/tv/LauncherRecommendationsManager.kt b/app/src/main/java/com/streamvault/app/tv/LauncherRecommendationsManager.kt
index acbacfcb..fbe87dd3 100644
--- a/app/src/main/java/com/streamvault/app/tv/LauncherRecommendationsManager.kt
+++ b/app/src/main/java/com/streamvault/app/tv/LauncherRecommendationsManager.kt
@@ -15,7 +15,7 @@ import androidx.annotation.RequiresApi
import com.streamvault.app.MainActivity
import com.streamvault.app.R
import com.streamvault.app.device.isTelevisionDevice
-import com.streamvault.app.navigation.ExternalDestination
+import com.streamvault.core.navigation.AppDestination
import com.streamvault.core.navigation.PlayerNavigationRequest
import com.streamvault.app.navigation.toPlayerNavigationRequest
import com.streamvault.domain.model.ActiveLiveSource
@@ -195,7 +195,7 @@ class LauncherRecommendationsManager @Inject constructor(
description = series.plot ?: series.genre ?: provider.name,
posterArtUri = artworkUri(series.posterUrl ?: series.backdropUrl),
intentUri = buildDestinationIntent(
- ExternalDestination.SeriesDetail(series.id)
+ AppDestination.SeriesDetail(series.id)
).toUri(Intent.URI_INTENT_SCHEME),
weight = (FRESH_SERIES_WEIGHT_BASE - index).coerceAtLeast(0),
durationMillis = 0L,
@@ -364,14 +364,14 @@ class LauncherRecommendationsManager @Inject constructor(
.putExtra(MainActivity.EXTRA_PLAYER_REQUEST, request)
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
- private fun buildDestinationIntent(destination: ExternalDestination): Intent =
+ private fun buildDestinationIntent(destination: AppDestination): Intent =
Intent(context, MainActivity::class.java)
.setAction(Intent.ACTION_VIEW)
.putExtra(MainActivity.EXTRA_EXTERNAL_DESTINATION, destination)
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
private fun buildBrowseIntent(): Intent =
- buildDestinationIntent(ExternalDestination.Home)
+ buildDestinationIntent(AppDestination.Home)
@RequiresApi(Build.VERSION_CODES.O)
private fun requestChannelBrowsable(channelId: Long) {
diff --git a/app/src/main/java/com/streamvault/app/tvinput/TvInputSetupActivity.kt b/app/src/main/java/com/streamvault/app/tvinput/TvInputSetupActivity.kt
index 314c1b51..deb81da1 100644
--- a/app/src/main/java/com/streamvault/app/tvinput/TvInputSetupActivity.kt
+++ b/app/src/main/java/com/streamvault/app/tvinput/TvInputSetupActivity.kt
@@ -38,7 +38,7 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.lifecycle.viewModelScope
import com.streamvault.app.R
import com.streamvault.app.MainActivity
-import com.streamvault.app.navigation.ExternalDestination
+import com.streamvault.core.navigation.AppDestination
import com.streamvault.core.ui.theme.ErrorColor
import com.streamvault.core.ui.theme.OnBackground
import com.streamvault.core.ui.theme.OnSurfaceDim
@@ -74,7 +74,7 @@ class TvInputSetupActivity : ComponentActivity() {
Intent(this, MainActivity::class.java)
.putExtra(
MainActivity.EXTRA_EXTERNAL_DESTINATION,
- ExternalDestination.ProviderSetup()
+ AppDestination.ProviderSetup()
)
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
)
diff --git a/app/src/test/java/com/streamvault/app/navigation/AppNavigationCoordinatorTest.kt b/app/src/test/java/com/streamvault/app/navigation/AppNavigationCoordinatorTest.kt
new file mode 100644
index 00000000..0adc2a8a
--- /dev/null
+++ b/app/src/test/java/com/streamvault/app/navigation/AppNavigationCoordinatorTest.kt
@@ -0,0 +1,39 @@
+package com.streamvault.app.navigation
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.core.navigation.AppDestination
+import com.streamvault.core.navigation.ExternalNavigationRequest
+import org.junit.Test
+
+class AppNavigationCoordinatorTest {
+ @Test
+ fun commandIsClearedOnlyAfterMatchingAcknowledgement() {
+ val ids = sequenceOf(10L, 11L).iterator()
+ val coordinator = AppNavigationCoordinator(NavigationCommandIdSource { ids.next() })
+ coordinator.submitExternalRequest(ExternalNavigationRequest.Search("news"))
+
+ val pending = coordinator.pendingCommand.value
+ assertThat(pending?.id).isEqualTo(10L)
+ coordinator.acknowledge(11L)
+ assertThat(coordinator.pendingCommand.value).isEqualTo(pending)
+ coordinator.acknowledge(10L)
+ assertThat(coordinator.pendingCommand.value).isNull()
+ }
+
+ @Test
+ fun queuedCommandsArePublishedInSubmissionOrder() {
+ val ids = sequenceOf(10L, 11L).iterator()
+ val coordinator = AppNavigationCoordinator(NavigationCommandIdSource { ids.next() })
+ coordinator.submitExternalRequest(ExternalNavigationRequest.Search("news"))
+ coordinator.submitExternalRequest(ExternalNavigationRequest.Destination(AppDestination.Home))
+
+ val first = coordinator.pendingCommand.value
+ assertThat(first?.id).isEqualTo(10L)
+ coordinator.acknowledge(10L)
+ assertThat(coordinator.pendingCommand.value?.id).isEqualTo(11L)
+ assertThat(coordinator.pendingCommand.value?.command)
+ .isEqualTo(
+ ExternalNavigationRequest.Destination(AppDestination.Home).toNavigationCommand()
+ )
+ }
+}
diff --git a/app/src/test/java/com/streamvault/app/navigation/ExternalNavigationRequestParserTest.kt b/app/src/test/java/com/streamvault/app/navigation/ExternalNavigationRequestParserTest.kt
new file mode 100644
index 00000000..8fabb19c
--- /dev/null
+++ b/app/src/test/java/com/streamvault/app/navigation/ExternalNavigationRequestParserTest.kt
@@ -0,0 +1,124 @@
+package com.streamvault.app.navigation
+
+import android.app.SearchManager
+import android.content.Intent
+import android.net.Uri
+import android.speech.RecognizerIntent
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.app.MainActivity
+import com.streamvault.core.navigation.AppDestination
+import com.streamvault.core.navigation.ExternalNavigationRequest
+import com.streamvault.core.navigation.PlayerNavigationRequest
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@RunWith(RobolectricTestRunner::class)
+class ExternalNavigationRequestParserTest {
+ private val context = RuntimeEnvironment.getApplication()
+ private val parser = ExternalNavigationRequestParser(context)
+
+ @Test
+ fun searchIntentBecomesTypedSearchRequest() {
+ val intent = Intent(Intent.ACTION_SEARCH)
+ .putExtra(SearchManager.QUERY, " sports ")
+
+ assertThat(parser.parse(intent))
+ .isEqualTo(ExternalNavigationRequest.Search("sports"))
+ }
+
+ @Test
+ fun malformedLegacyRouteFallsBackHome() {
+ val intent = Intent().putExtra(MainActivity.EXTRA_EXTERNAL_ROUTE, "bad/route")
+
+ assertThat(parser.parse(intent)).isEqualTo(
+ ExternalNavigationRequest.Destination(AppDestination.Home)
+ )
+ }
+
+ @Test
+ fun playlistMimeWithContentUriBecomesImportRequest() {
+ val uri = Uri.parse("content://example/playlist")
+ val intent = Intent(Intent.ACTION_VIEW)
+ .setDataAndType(uri, "audio/x-mpegurl")
+
+ assertThat(parser.parse(intent))
+ .isEqualTo(ExternalNavigationRequest.ImportM3u(uri.toString()))
+ }
+
+ @Test
+ fun playlistPathWithoutMimeBecomesImportRequest() {
+ val uri = Uri.parse("file:///sdcard/playlist.m3u8")
+ val intent = Intent(Intent.ACTION_VIEW).setData(uri)
+
+ assertThat(parser.parse(intent))
+ .isEqualTo(ExternalNavigationRequest.ImportM3u(uri.toString()))
+ }
+
+ @Test
+ fun backupJsonStreamBecomesImportRequest() {
+ val uri = Uri.parse("content://example/backup.json")
+ val intent = Intent(Intent.ACTION_SEND)
+ .setType("application/json")
+ .putExtra(Intent.EXTRA_STREAM, uri)
+
+ assertThat(parser.parse(intent))
+ .isEqualTo(ExternalNavigationRequest.ImportBackup(uri.toString()))
+ }
+
+ @Test
+ fun playerExtraTakesPrecedence() {
+ val request = PlayerNavigationRequest(
+ streamUrl = "https://example.com/live.m3u8",
+ title = "News"
+ )
+ val intent = Intent(Intent.ACTION_VIEW)
+ .putExtra(MainActivity.EXTRA_PLAYER_REQUEST, request)
+ .putExtra(MainActivity.EXTRA_EXTERNAL_ROUTE, "home")
+
+ assertThat(parser.parse(intent))
+ .isEqualTo(ExternalNavigationRequest.Player(request))
+ }
+
+ @Test
+ fun typedDestinationExtraBecomesDestinationRequest() {
+ val intent = Intent()
+ .putExtra(
+ MainActivity.EXTRA_EXTERNAL_DESTINATION,
+ AppDestination.Settings(backupUri = "content://example/backup.json")
+ )
+
+ assertThat(parser.parse(intent)).isEqualTo(
+ ExternalNavigationRequest.Destination(
+ AppDestination.Settings(backupUri = "content://example/backup.json")
+ )
+ )
+ }
+
+ @Test
+ fun genericViewFallsBackHome() {
+ val intent = Intent(Intent.ACTION_VIEW)
+ .setData(Uri.parse("https://example.com/watch/42"))
+
+ assertThat(parser.parse(intent)).isEqualTo(
+ ExternalNavigationRequest.Destination(AppDestination.Home)
+ )
+ }
+
+ @Test
+ fun blankSearchAssistantAndVoiceQueriesProduceNoRequest() {
+ assertThat(
+ parser.parse(Intent(Intent.ACTION_SEARCH).putExtra(SearchManager.QUERY, " "))
+ ).isNull()
+ assertThat(
+ parser.parse(Intent(Intent.ACTION_ASSIST).putExtra(SearchManager.QUERY, ""))
+ ).isNull()
+ assertThat(
+ parser.parse(
+ Intent(RecognizerIntent.ACTION_VOICE_SEARCH_HANDS_FREE)
+ .putStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS, arrayListOf(" "))
+ )
+ ).isNull()
+ }
+}