StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
Handle external chooser cancellation
dev.salmontech388c99cebf74
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerScreen.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerScreen.ktindex 462484d1..23ca4b4c 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerScreen.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerScreen.kt@@ -1,10 +1,18 @@package com.streamvault.app.ui.screens.playerimport android.app.Activity+import android.app.PendingIntent+import android.content.BroadcastReceiver+import android.content.Context+import android.content.Intent+import android.content.IntentFilter+import android.os.Buildimport android.util.Logimport android.view.KeyEventimport android.view.WindowManagerimport androidx.activity.compose.BackHandler+import androidx.activity.compose.rememberLauncherForActivityResult+import androidx.activity.result.contract.ActivityResultContractsimport androidx.compose.foundation.backgroundimport androidx.compose.foundation.layout.*import androidx.compose.foundation.shape.RoundedCornerShape@@ -46,7 +54,6 @@ import androidx.media3.common.util.UnstableApiimport androidx.tv.material3.*import com.streamvault.app.device.rememberIsTelevisionDeviceimport com.streamvault.app.ui.theme.*-import com.streamvault.app.player.external.ExternalPlayerLaunchResultimport com.streamvault.app.player.external.ExternalPlayerLauncherimport com.streamvault.domain.model.DecoderModeimport com.streamvault.domain.model.ExternalPlaybackMode@@ -108,6 +115,8 @@ import com.streamvault.app.ui.screens.multiview.MultiViewViewModelimport com.streamvault.app.ui.screens.multiview.MultiViewPlannerDialogimport com.streamvault.app.navigation.Routes+private const val EXTERNAL_PLAYER_LAUNCH_KEY_EXTRA = "com.streamvault.app.extra.EXTERNAL_PLAYER_LAUNCH_KEY"+@OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class)@@ -155,6 +164,40 @@ fun PlayerScreen(}val mainActivity = LocalContext.current.findMainActivity()val appContext = LocalContext.current+ val externalPlayerChosenAction = remember(appContext) {+ "${appContext.packageName}.EXTERNAL_PLAYER_CHOSEN.${System.nanoTime()}"+ }+ var pendingExternalLaunchKey by rememberSaveable { mutableStateOf<String?>(null) }+ var chosenExternalLaunchKey by rememberSaveable { mutableStateOf<String?>(null) }+ val externalPlayerLauncher = rememberLauncherForActivityResult(+ contract = ActivityResultContracts.StartActivityForResult()+ ) { result ->+ val pendingKey = pendingExternalLaunchKey+ if (result.resultCode == Activity.RESULT_CANCELED && pendingKey != null && chosenExternalLaunchKey != pendingKey) {+ pendingExternalLaunchKey = null+ viewModel.playResolvedStreamInternally()+ viewModel.showPlayerNotice(message = "Playing internally.")+ }+ }+ DisposableEffect(appContext, externalPlayerChosenAction) {+ val receiver = object : BroadcastReceiver() {+ override fun onReceive(context: Context?, intent: Intent?) {+ val launchKey = intent?.getStringExtra(EXTERNAL_PLAYER_LAUNCH_KEY_EXTRA) ?: return+ chosenExternalLaunchKey = launchKey+ if (pendingExternalLaunchKey == launchKey) {+ pendingExternalLaunchKey = null+ }+ }+ }+ val filter = IntentFilter(externalPlayerChosenAction)+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {+ appContext.registerReceiver(receiver, filter, Context.RECEIVER_NOT_EXPORTED)+ } else {+ @Suppress("DEPRECATION")+ appContext.registerReceiver(receiver, filter)+ }+ onDispose { appContext.unregisterReceiver(receiver) }+ }val notificationPermissionGate = rememberNotificationPermissionGate(onNotificationsBlocked = { message -> viewModel.showPlayerNotice(message = message) },reminderBlockedMessage = stringResource(R.string.notification_permission_reminder_required),@@ -473,7 +516,7 @@ fun PlayerScreen(}LaunchedEffect(externalPlaybackMode, prepareIdentity, externalPlaybackUrl) {- if (externalPlaybackMode == ExternalPlaybackMode.EXTERNAL_PLAYER) {+ if (externalPlaybackMode != ExternalPlaybackMode.INTERNAL_PLAYER) {val launchUrl = externalPlaybackUrlif (launchUrl.isBlank()) return@LaunchedEffectval launchKey = prepareIdentity.toString()@@ -485,29 +528,42 @@ fun PlayerScreen()return@LaunchedEffect}- val result = ExternalPlayerLauncher.launch(appContext, launchUrl)- when (result) {- is ExternalPlayerLaunchResult.Success -> {- Log.d("PlayerScreen", "External player launched successfully for: ${result.url}")- }- is ExternalPlayerLaunchResult.InvalidUrl -> {- Log.w("PlayerScreen", "External player launch failed - invalid URL: ${result.reason}")- viewModel.showPlayerNotice(- message = "Cannot launch external player: ${result.reason}"- )- }- is ExternalPlayerLaunchResult.NoHandler -> {- Log.w("PlayerScreen", "External player launch failed - no handler available for: ${result.url}")- viewModel.showPlayerNotice(- message = "No external player found. Playing internally."- )- }- is ExternalPlayerLaunchResult.Failed -> {- Log.w("PlayerScreen", "External player launch failed: ${result.errorMessage}")- viewModel.showPlayerNotice(- message = "External player failed. Playing internally."- )- }+ val intent = ExternalPlayerLauncher.buildExternalPlayerIntent(launchUrl)+ if (intent == null) {+ viewModel.showPlayerNotice(+ message = "Cannot launch external player: Invalid or non-whitelisted URL scheme"+ )+ return@LaunchedEffect+ }+ if (intent.resolveActivity(appContext.packageManager) == null) {+ Log.w("PlayerScreen", "External player launch failed - no handler available for: $launchUrl")+ viewModel.playResolvedStreamInternally()+ viewModel.showPlayerNotice(message = "No external player found. Playing internally.")+ return@LaunchedEffect+ }+ val chosenCallback = Intent(externalPlayerChosenAction)+ .setPackage(appContext.packageName)+ .putExtra(EXTERNAL_PLAYER_LAUNCH_KEY_EXTRA, launchKey)+ val chosenSender = PendingIntent.getBroadcast(+ appContext,+ launchKey.hashCode(),+ chosenCallback,+ PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE+ ).intentSender+ val chooser = Intent.createChooser(intent, null).apply {+ putExtra(Intent.EXTRA_CHOSEN_COMPONENT_INTENT_SENDER, chosenSender)+ }+ pendingExternalLaunchKey = launchKey+ chosenExternalLaunchKey = null+ runCatching {+ externalPlayerLauncher.launch(chooser)+ }.onSuccess {+ Log.d("PlayerScreen", "External player chooser launched for: $launchUrl")+ }.onFailure { error ->+ pendingExternalLaunchKey = null+ Log.w("PlayerScreen", "External player chooser failed: ${error.message}", error)+ viewModel.playResolvedStreamInternally()+ viewModel.showPlayerNotice(message = "External player failed. Playing internally.")}}}diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.ktindex 87fd8a61..64fdc195 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt@@ -27,6 +27,7 @@ import com.streamvault.domain.model.Programimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.DecoderModeimport com.streamvault.domain.model.Episode+import com.streamvault.domain.model.ExternalPlaybackModeimport com.streamvault.domain.model.Favoriteimport com.streamvault.domain.model.LiveChannelObservedQualityimport com.streamvault.domain.model.PlaybackHistory@@ -1151,13 +1152,64 @@ class PlayerViewModel @Inject constructor(requestVersion: Long,probeBeforePlayback: Boolean = true): Boolean {+ val preparedStreamInfo = prepareStreamInfoForPlayback(+ streamInfo = streamInfo,+ requestVersion = requestVersion,+ probeBeforePlayback = probeBeforePlayback+ ) ?: return false++ applyPlaybackPreferences()+ if (!isActivePlaybackSession(requestVersion)) return false+ currentResolvedPlaybackUrl = preparedStreamInfo.url+ currentResolvedStreamInfo = preparedStreamInfo+ readySideEffectsRequestVersion = requestVersion+ playerEngine.prepare(preparedStreamInfo)+ startTokenRenewalMonitoring(preparedStreamInfo.expirationTime)+ return true+ }++ internal suspend fun prepareExternalPlaybackUrl(+ streamInfo: com.streamvault.domain.model.StreamInfo,+ requestVersion: Long,+ probeBeforePlayback: Boolean = true+ ): Boolean {+ val preparedStreamInfo = prepareStreamInfoForPlayback(+ streamInfo = streamInfo,+ requestVersion = requestVersion,+ probeBeforePlayback = probeBeforePlayback+ ) ?: return false+if (!isActivePlaybackSession(requestVersion)) return false+ currentResolvedPlaybackUrl = preparedStreamInfo.url+ currentResolvedStreamInfo = preparedStreamInfo+ readySideEffectsRequestVersion = requestVersion+ playerEngine.stopLiveTimeshift()+ playerEngine.stop()+ return true+ }++ fun playResolvedStreamInternally() {+ val streamInfo = currentResolvedStreamInfo ?: return+ viewModelScope.launch {+ applyPlaybackPreferences()+ playerEngine.prepare(streamInfo)+ startTokenRenewalMonitoring(streamInfo.expirationTime)+ maybeStartLiveTimeshift(streamInfo)+ }+ }++ private suspend fun prepareStreamInfoForPlayback(+ streamInfo: com.streamvault.domain.model.StreamInfo,+ requestVersion: Long,+ probeBeforePlayback: Boolean+ ): com.streamvault.domain.model.StreamInfo? {+ if (!isActivePlaybackSession(requestVersion)) return null// Fast-path expiry check: if the stream URL already carries an expiration timestamp// that is in the past, skip the network probe entirely and surface a clear message.val expiry = streamInfo.expirationTimeif (expiry != null && expiry > 0L && expiry < System.currentTimeMillis()) {- if (!isActivePlaybackSession(requestVersion)) return false+ if (!isActivePlaybackSession(requestVersion)) return nullval expiryMessage = "This stream's subscription has expired. " +"Please renew your subscription with the provider."setLastFailureReason(expiryMessage)@@ -1166,20 +1218,20 @@ class PlayerViewModel @Inject constructor(recoveryType = PlayerRecoveryType.SOURCE,actions = buildRecoveryActions(PlayerRecoveryType.SOURCE))- return false+ return null}var preparedStreamInfo = streamInfowhen (val pluginPrepareResult = pluginManager.preparePlaybackStreamInfo(streamInfo)) {is Result.Error -> {- if (!isActivePlaybackSession(requestVersion)) return false+ if (!isActivePlaybackSession(requestVersion)) return nullsetLastFailureReason(pluginPrepareResult.message)showPlayerNotice(message = pluginPrepareResult.message,recoveryType = PlayerRecoveryType.NETWORK,actions = buildRecoveryActions(PlayerRecoveryType.NETWORK))- return false+ return null}Result.Loading -> Unitis Result.Success -> preparedStreamInfo = pluginPrepareResult.data@@ -1187,14 +1239,14 @@ class PlayerViewModel @Inject constructor(if (probeBeforePlayback) {probePlaybackUrl(preparedStreamInfo)?.let { failure ->- if (!isActivePlaybackSession(requestVersion)) return false+ if (!isActivePlaybackSession(requestVersion)) return nullsetLastFailureReason(failure.message)showPlayerNotice(message = failure.message,recoveryType = failure.recoveryType,actions = buildRecoveryActions(failure.recoveryType))- return false+ return null}probePassedPlaybackKeys.add(resolvePlaybackProbeCacheKey(@@ -1203,14 +1255,7 @@ class PlayerViewModel @Inject constructor())}- applyPlaybackPreferences()- if (!isActivePlaybackSession(requestVersion)) return false- currentResolvedPlaybackUrl = preparedStreamInfo.url- currentResolvedStreamInfo = preparedStreamInfo- readySideEffectsRequestVersion = requestVersion- playerEngine.prepare(preparedStreamInfo)- startTokenRenewalMonitoring(preparedStreamInfo.expirationTime)- return true+ return preparedStreamInfo}private suspend fun probePlaybackUrl(streamInfo: com.streamvault.domain.model.StreamInfo): PlaybackProbeFailure? {@@ -1323,7 +1368,8 @@ class PlayerViewModel @Inject constructor(if (!hasArchiveRequest) {viewModelScope.launch {- if (tryAdoptPreviewHandoff(requestVersion, internalChannelId, providerId)) {+ val externalMode = playerPreferencesUiState.value.externalPlaybackMode != ExternalPlaybackMode.INTERNAL_PLAYER+ if (!externalMode && tryAdoptPreviewHandoff(requestVersion, internalChannelId, providerId)) {return@launch}var playbackLogicalUrl = streamUrl@@ -1376,6 +1422,10 @@ class PlayerViewModel @Inject constructor(currentStreamUrl = playbackLogicalUrlcurrentContentId = playbackContentIdif (!isActivePlaybackSession(requestVersion, playbackLogicalUrl)) return@launch+ if (externalMode) {+ prepareExternalPlaybackUrl(streamInfo, requestVersion)+ return@launch+ }if (!preparePlayer(streamInfo, requestVersion)) return@launch// Check for resume position after the player is fully prepared (VOD only).diff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreenDialogs.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreenDialogs.ktindex 67b7f1c6..b225997e 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreenDialogs.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreenDialogs.kt@@ -309,6 +309,7 @@ internal fun ExternalPlaybackModeDialog(onDismiss: () -> Unit,onModeSelected: (ExternalPlaybackMode) -> Unit) {+ val modes = listOf(ExternalPlaybackMode.INTERNAL_PLAYER, ExternalPlaybackMode.EXTERNAL_PLAYER)PremiumDialog(title = stringResource(R.string.settings_external_playback),subtitle = stringResource(R.string.settings_external_playback_subtitle),@@ -316,12 +317,14 @@ internal fun ExternalPlaybackModeDialog(widthFraction = 0.52f,content = {Column(verticalArrangement = Arrangement.spacedBy(10.dp)) {- ExternalPlaybackMode.entries.forEach { mode ->+ modes.forEach { mode ->+ val isSelected = mode == selectedMode ||+ (mode == ExternalPlaybackMode.EXTERNAL_PLAYER && selectedMode == ExternalPlaybackMode.ASK_EVERY_TIME)TvClickableSurface(onClick = { onModeSelected(mode) },shape = ClickableSurfaceDefaults.shape(RoundedCornerShape(14.dp)),colors = ClickableSurfaceDefaults.colors(- containerColor = if (mode == selectedMode) Primary.copy(alpha = 0.18f) else SurfaceElevated,+ containerColor = if (isSelected) Primary.copy(alpha = 0.18f) else SurfaceElevated,focusedContainerColor = Primary.copy(alpha = 0.28f)),modifier = Modifier.fillMaxWidth()@@ -334,12 +337,12 @@ internal fun ExternalPlaybackModeDialog(text = stringResource(when (mode) {ExternalPlaybackMode.INTERNAL_PLAYER -> R.string.settings_external_playback_mode_internal- ExternalPlaybackMode.ASK_EVERY_TIME -> R.string.settings_external_playback_mode_askExternalPlaybackMode.EXTERNAL_PLAYER -> R.string.settings_external_playback_mode_external+ ExternalPlaybackMode.ASK_EVERY_TIME -> R.string.settings_external_playback_mode_external}),style = androidx.compose.material3.MaterialTheme.typography.titleSmall,- color = if (mode == selectedMode) Primary else OnBackground+ color = if (isSelected) Primary else OnBackground)}}diff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreenState.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreenState.ktindex 1b6f1782..db2fa7ec 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreenState.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreenState.kt@@ -236,6 +236,6 @@ private fun formatExternalPlaybackModeLabel(context: Context): String = when (mode) {com.streamvault.domain.model.ExternalPlaybackMode.INTERNAL_PLAYER -> context.getString(R.string.settings_external_playback_mode_internal)- com.streamvault.domain.model.ExternalPlaybackMode.ASK_EVERY_TIME -> context.getString(R.string.settings_external_playback_mode_ask)+ com.streamvault.domain.model.ExternalPlaybackMode.ASK_EVERY_TIME -> context.getString(R.string.settings_external_playback_mode_external)com.streamvault.domain.model.ExternalPlaybackMode.EXTERNAL_PLAYER -> context.getString(R.string.settings_external_playback_mode_external)}diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xmlindex 361f2f03..2cc9c8a8 100644--- a/app/src/main/res/values/strings.xml+++ b/app/src/main/res/values/strings.xml@@ -358,7 +358,6 @@<string name="settings_external_playback">Default playback app</string><string name="settings_external_playback_subtitle">Choose which app opens streams when you play a channel or title.</string><string name="settings_external_playback_mode_internal">Internal player</string>- <string name="settings_external_playback_mode_ask">Ask every time</string><string name="settings_external_playback_mode_external">External player</string><string name="settings_browsing">Browsing</string><string name="settings_live_tv_channel_mode">Live TV Channel Mode</string>diff --git a/docs/external-player-chooser-cancel-handoff.md b/docs/external-player-chooser-cancel-handoff.mdnew file mode 100644index 00000000..32fa5256--- /dev/null+++ b/docs/external-player-chooser-cancel-handoff.md@@ -0,0 +1,81 @@+# External Player Chooser Cancel Handoff++## Baseline++- Latest committed work: `144f4ce Fix external playback URL handoff`.+- User validated that commit on device:+ - Copy URL works.+ - Direct VLC playback works.+- Current working tree has uncommitted follow-up changes in:+ - `app/src/main/java/com/streamvault/app/ui/screens/player/PlayerScreen.kt`+ - `app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt`+ - `app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreenDialogs.kt`+ - `app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreenState.kt`+ - `app/src/main/res/values/strings.xml`++## User Correction++- Real issue is not playback after VLC is selected.+- Real issue:+ 1. Setting is `External player`.+ 2. User presses Play.+ 3. Android chooser opens with VLC option.+ 4. Before user taps VLC, StreamVault internal player starts playing behind chooser.+ 5. Internal player must stay stopped while chooser is open.+ 6. If user selects VLC, keep internal player stopped.+ 7. If user dismisses chooser/taps outside/back, then start internal playback as fallback.+- `Ask every time` option in Default playback app should be removed. Existing saved `ask` can behave as External player.++## Current Uncommitted Implementation Attempt++- `PlayerViewModel.kt` was refactored so external mode resolves/probes URL without preparing Media3:+ - Added `prepareStreamInfoForPlayback(...)` helper.+ - `preparePlayer(...)` now prepares internal player only after helper returns resolved `StreamInfo`.+ - Added `prepareExternalPlaybackUrl(...)` to set `currentResolvedPlaybackUrl/currentResolvedStreamInfo`, stop timeshift, and stop player without preparing playback.+ - Added `playResolvedStreamInternally()` fallback that prepares the saved resolved `StreamInfo` inside `viewModelScope.launch`.+ - Main `prepare(...)` path uses external-only resolution when `externalPlaybackMode != INTERNAL_PLAYER`.+- `PlayerScreen.kt` was changed to use chooser-aware launch:+ - Uses `rememberLauncherForActivityResult(ActivityResultContracts.StartActivityForResult())`.+ - Uses `Intent.createChooser(...)` plus `Intent.EXTRA_CHOSEN_COMPONENT_INTENT_SENDER`.+ - Registers a per-screen `BroadcastReceiver` to detect actual external app selection.+ - If Activity Result returns `RESULT_CANCELED` and no chosen callback was received, calls `viewModel.playResolvedStreamInternally()`.+- Settings changes:+ - `SettingsScreenDialogs.kt` lists only `INTERNAL_PLAYER` and `EXTERNAL_PLAYER`.+ - Existing `ASK_EVERY_TIME` selected state displays as External player.+ - `SettingsScreenState.kt` maps `ASK_EVERY_TIME` label to External player.+ - Removed `settings_external_playback_mode_ask` string from default `strings.xml`.++## Verification State++- `gradlew.bat :app:compileDebugKotlin --no-daemon --console=plain` passed after chooser patch.+- Then tests and assemble were accidentally run in parallel. This was wrong for this Gradle project and caused build-output races.+- Afterward, serial targeted tests still failed:+ - Command: `gradlew.bat :app:cleanTestDebugUnitTest :app:testDebugUnitTest --tests com.streamvault.app.player.external.* --no-daemon --console=plain`+ - Failure: all external-player tests fail with `NoClassDefFoundError` at calls to `ExternalPlayerLauncher` / `inferExternalPlayerMimeType`.+ - This looks like stale/corrupt test classpath/build intermediates from the previous parallel Gradle run, not a Kotlin compile error.+- APK assemble after chooser patch has not been successfully re-run after the failed parallel run.++## Recommended Next Steps++1. Do not run Gradle tasks in parallel in this project.+2. First inspect current uncommitted diff:+ - `git status --short`+ - `git diff -- app/src/main/java/com/streamvault/app/ui/screens/player/PlayerScreen.kt app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreenDialogs.kt app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsScreenState.kt app/src/main/res/values/strings.xml`+3. Recover build state with one serial clean command:+ - `gradlew.bat clean :app:compileDebugKotlin --no-daemon --console=plain`+4. If compile passes, run targeted tests serially:+ - `gradlew.bat :app:testDebugUnitTest --tests com.streamvault.app.player.external.* --no-daemon --console=plain`+5. If tests still show `NoClassDefFoundError`, inspect generated test report for exact missing class and run full app clean again before code changes.+6. Build APK serially only after tests/compile:+ - `gradlew.bat :app:assembleDebug --no-daemon --console=plain`+7. Device-test exact behavior:+ - External selected, press Play, chooser visible: internal audio/video must not start.+ - Tap VLC: VLC plays, StreamVault stays stopped.+ - Dismiss chooser: StreamVault starts internal fallback.+8. If chooser cancel is not detected reliably by `StartActivityForResult`, keep internal stopped while chooser is visible and implement explicit in-app fallback notice/button after returning to StreamVault.++## Caution++- Do not revert `144f4ce`; user confirmed it works.+- Current uncommitted changes are not yet verified on device.+- The chooser callback approach compiles, but Android resolver behavior must be device-tested.