Skip to content

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

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.kt
index 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.player
import 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.Build
import android.util.Log
import android.view.KeyEvent
import android.view.WindowManager
import androidx.activity.compose.BackHandler
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.RoundedCornerShape
@@ -46,7 +54,6 @@ import androidx.media3.common.util.UnstableApi
import androidx.tv.material3.*
import com.streamvault.app.device.rememberIsTelevisionDevice
import com.streamvault.app.ui.theme.*
-import com.streamvault.app.player.external.ExternalPlayerLaunchResult
import com.streamvault.app.player.external.ExternalPlayerLauncher
import com.streamvault.domain.model.DecoderMode
import com.streamvault.domain.model.ExternalPlaybackMode
@@ -108,6 +115,8 @@ import com.streamvault.app.ui.screens.multiview.MultiViewViewModel
import com.streamvault.app.ui.screens.multiview.MultiViewPlannerDialog
import 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 = externalPlaybackUrl
if (launchUrl.isBlank()) return@LaunchedEffect
val 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.kt
index 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.Program
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.DecoderMode
import com.streamvault.domain.model.Episode
+import com.streamvault.domain.model.ExternalPlaybackMode
import com.streamvault.domain.model.Favorite
import com.streamvault.domain.model.LiveChannelObservedQuality
import 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.expirationTime
if (expiry != null && expiry > 0L && expiry < System.currentTimeMillis()) {
- if (!isActivePlaybackSession(requestVersion)) return false
+ if (!isActivePlaybackSession(requestVersion)) return null
val 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 = streamInfo
when (val pluginPrepareResult = pluginManager.preparePlaybackStreamInfo(streamInfo)) {
is Result.Error -> {
- if (!isActivePlaybackSession(requestVersion)) return false
+ if (!isActivePlaybackSession(requestVersion)) return null
setLastFailureReason(pluginPrepareResult.message)
showPlayerNotice(
message = pluginPrepareResult.message,
recoveryType = PlayerRecoveryType.NETWORK,
actions = buildRecoveryActions(PlayerRecoveryType.NETWORK)
)
- return false
+ return null
}
Result.Loading -> Unit
is 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 null
setLastFailureReason(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 = playbackLogicalUrl
currentContentId = playbackContentId
if (!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.kt
index 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_ask
ExternalPlaybackMode.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.kt
index 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.xml
index 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.md
new file mode 100644
index 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.