feat(catchup): launch past Guide programmes through service-owned playback intent

app/tv/src/main/kotlin/app/muxtv/navigation/AppDestination.kt

@@ -32,14 +32,38 @@ sealed interface AppDestination : NavKey {
     @Serializable
     data class Player(
         val channelId: String,
+        val programmeId: String? = null,
+        val programmeStartEpochMillis: Long? = null,
+        val programmeEndEpochMillis: Long? = null,
     ) : AppDestination {
         init {
             require(channelId.isNotBlank())
+            val programmeTuple = listOf(
+                programmeId,
+                programmeStartEpochMillis,
+                programmeEndEpochMillis,
+            )
+            require(programmeTuple.all { it == null } || programmeTuple.all { it != null })
+            if (programmeId != null &&
+                programmeStartEpochMillis != null &&
+                programmeEndEpochMillis != null
+            ) {
+                require(programmeId.isNotBlank())
+                require(programmeId.length <= MAX_PROGRAMME_ID_LENGTH)
+                require(programmeStartEpochMillis >= 0L)
+                require(programmeEndEpochMillis > programmeStartEpochMillis)
+            }
         }
+
+        override fun toString(): String =
+            "AppDestination.Player(channelId=<redacted>, " +
+                "programmePresent=${programmeId != null})"
     }
 
     companion object {
         val initial: AppDestination = Home
         val topLevel: List<AppDestination> = listOf(Home, Channels, Guide, Search, Settings)
     }
 }
+
+private const val MAX_PROGRAMME_ID_LENGTH = 80

app/tv/src/main/kotlin/app/muxtv/navigation/AppNavigation.kt

@@ -160,6 +160,9 @@ fun AppNavigation(
                                 open(AppDestination.Player(channelId))
                             },
                             railFocusRequester = railFocusRequester,
+                            onPlaybackSelected = { selection ->
+                                open(selection.toPlayerDestination())
+                            },
                         )
 
                         AppDestination.Search -> SearchRoute(
@@ -199,26 +202,30 @@ fun AppNavigation(
                             openLocalNetworkPermissionSettings = openLocalNetworkPermissionSettings,
                         )
 
-                        is AppDestination.Player -> PlayerFavoriteRoute(
-                            playbackCatalog = playbackCatalog,
-                            channelPreferencesRepository = channelPreferencesRepository,
-                            playbackSessionGateway = playbackSessionGateway,
-                            playbackSurface = { session, surfaceModifier ->
-                                Media3PlaybackSurface(
-                                    session = session,
-                                    modifier = surfaceModifier,
-                                )
-                            },
-                            profileId = DatabaseDefaults.PRIMARY_PROFILE_ID,
-                            channelId = destination.channelId,
-                            onBack = ::goBack,
-                            onOpenDoctor = ::openDoctorFromPlayer,
-                            playbackStartGateway = playbackStartGateway,
-                            requestLocalNetworkPermission = {
-                                requestLocalNetworkPermission().toPlayerOutcome()
-                            },
-                            openLocalNetworkPermissionSettings = openLocalNetworkPermissionSettings,
-                        )
+                        is AppDestination.Player -> {
+                            val playbackIntent = destination.toPlaybackIntent()
+                            PlayerFavoriteRoute(
+                                playbackCatalog = playbackCatalog,
+                                channelPreferencesRepository = channelPreferencesRepository,
+                                playbackSessionGateway = playbackSessionGateway,
+                                playbackSurface = { session, surfaceModifier ->
+                                    Media3PlaybackSurface(
+                                        session = session,
+                                        modifier = surfaceModifier,
+                                    )
+                                },
+                                profileId = DatabaseDefaults.PRIMARY_PROFILE_ID,
+                                channelId = playbackIntent.channelId,
+                                onBack = ::goBack,
+                                onOpenDoctor = ::openDoctorFromPlayer,
+                                playbackStartGateway = playbackStartGateway,
+                                requestLocalNetworkPermission = {
+                                    requestLocalNetworkPermission().toPlayerOutcome()
+                                },
+                                openLocalNetworkPermissionSettings = openLocalNetworkPermissionSettings,
+                                playbackIntent = playbackIntent,
+                            )
+                        }
                     }
                 }
             },

app/tv/src/main/kotlin/app/muxtv/navigation/PlayerCatchupDestination.kt

@@ -0,0 +1,30 @@
+package app.muxtv.navigation
+
+import app.muxtv.feature.guide.GuidePlaybackSelection
+import app.muxtv.player.PlaybackIntent
+
+internal fun AppDestination.Player.toPlaybackIntent(): PlaybackIntent {
+    val resolvedProgrammeId = programmeId
+    val resolvedStart = programmeStartEpochMillis
+    val resolvedEnd = programmeEndEpochMillis
+    return if (resolvedProgrammeId == null || resolvedStart == null || resolvedEnd == null) {
+        PlaybackIntent.Live(channelId)
+    } else {
+        PlaybackIntent.CatchupProgram(
+            channelId = channelId,
+            programmeId = resolvedProgrammeId,
+            startEpochMillis = resolvedStart,
+            endEpochMillis = resolvedEnd,
+        )
+    }
+}
+
+internal fun GuidePlaybackSelection.toPlayerDestination(): AppDestination.Player = when (this) {
+    is GuidePlaybackSelection.Live -> AppDestination.Player(channelId)
+    is GuidePlaybackSelection.CatchupProgram -> AppDestination.Player(
+        channelId = channelId,
+        programmeId = programmeId,
+        programmeStartEpochMillis = startEpochMillis,
+        programmeEndEpochMillis = endEpochMillis,
+    )
+}

app/tv/src/main/kotlin/app/muxtv/navigation/PlayerFavoriteRoute.kt

@@ -16,6 +16,7 @@ import app.muxtv.feature.player.PlaybackSurfaceRenderer
 import app.muxtv.feature.player.PlayerFavoriteAction
 import app.muxtv.feature.player.PlayerLocalNetworkPermissionOutcome
 import app.muxtv.feature.player.PlayerRoute
+import app.muxtv.player.PlaybackIntent
 import app.muxtv.player.PlaybackSessionGateway
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.launch
@@ -36,19 +37,23 @@ internal fun PlayerFavoriteRoute(
     },
     openLocalNetworkPermissionSettings: suspend () -> Boolean = { false },
     modifier: Modifier = Modifier,
+    playbackIntent: PlaybackIntent = PlaybackIntent.Live(channelId),
 ) {
+    val playbackChannelId = playbackIntent.channelId
+    require(channelId == playbackChannelId)
+
     val scope = rememberCoroutineScope()
-    var favoriteOverride by remember(profileId, channelId) { mutableStateOf<Boolean?>(null) }
-    var mutationInProgress by remember(profileId, channelId) { mutableStateOf(false) }
-    var mutationFailed by remember(profileId, channelId) { mutableStateOf(false) }
+    var favoriteOverride by remember(profileId, playbackChannelId) { mutableStateOf<Boolean?>(null) }
+    var mutationInProgress by remember(profileId, playbackChannelId) { mutableStateOf(false) }
+    var mutationFailed by remember(profileId, playbackChannelId) { mutableStateOf(false) }
     val catalogFavorite by produceState<Boolean?>(
         initialValue = null,
         playbackCatalog,
         profileId,
-        channelId,
+        playbackChannelId,
     ) {
         value = try {
-            playbackCatalog.getChannel(profileId = profileId, channelId = channelId)
+            playbackCatalog.getChannel(profileId = profileId, channelId = playbackChannelId)
                 ?.summary
                 ?.isFavorite
         } catch (cancelled: CancellationException) {
@@ -64,7 +69,7 @@ internal fun PlayerFavoriteRoute(
         playbackSessionGateway = playbackSessionGateway,
         playbackSurface = playbackSurface,
         profileId = profileId,
-        channelId = channelId,
+        playbackIntent = playbackIntent,
         onBack = onBack,
         onOpenDoctor = onOpenDoctor,
         playbackStartGateway = playbackStartGateway,
@@ -86,7 +91,7 @@ internal fun PlayerFavoriteRoute(
                                 when (
                                     channelPreferencesRepository.setFavorite(
                                         profileId = profileId,
-                                        channelId = channelId,
+                                        channelId = playbackChannelId,
                                         isFavorite = requestedFavorite,
                                     )
                                 ) {

app/tv/src/test/kotlin/app/muxtv/navigation/PlayerCatchupDestinationTest.kt

@@ -0,0 +1,77 @@
+package app.muxtv.navigation
+
+import app.muxtv.feature.guide.GuidePlaybackSelection
+import app.muxtv.player.PlaybackIntent
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class PlayerCatchupDestinationTest {
+    @Test
+    fun `legacy player destination remains live`() {
+        val destination = AppDestination.Player(CHANNEL_ID)
+
+        assertThat(destination.toPlaybackIntent())
+            .isEqualTo(PlaybackIntent.Live(CHANNEL_ID))
+    }
+
+    @Test
+    fun `catchup destination reconstructs provider neutral programme intent`() {
+        val destination = AppDestination.Player(
+            channelId = CHANNEL_ID,
+            programmeId = PROGRAMME_ID,
+            programmeStartEpochMillis = PROGRAMME_START,
+            programmeEndEpochMillis = PROGRAMME_END,
+        )
+
+        assertThat(destination.toPlaybackIntent()).isEqualTo(
+            PlaybackIntent.CatchupProgram(
+                channelId = CHANNEL_ID,
+                programmeId = PROGRAMME_ID,
+                startEpochMillis = PROGRAMME_START,
+                endEpochMillis = PROGRAMME_END,
+            ),
+        )
+    }
+
+    @Test
+    fun `guide catchup selection maps to bounded player destination`() {
+        val destination = GuidePlaybackSelection.CatchupProgram(
+            channelId = CHANNEL_ID,
+            programmeId = PROGRAMME_ID,
+            startEpochMillis = PROGRAMME_START,
+            endEpochMillis = PROGRAMME_END,
+        ).toPlayerDestination()
+
+        assertThat(destination).isEqualTo(
+            AppDestination.Player(
+                channelId = CHANNEL_ID,
+                programmeId = PROGRAMME_ID,
+                programmeStartEpochMillis = PROGRAMME_START,
+                programmeEndEpochMillis = PROGRAMME_END,
+            ),
+        )
+    }
+
+    @Test
+    fun `guide live selection maps to legacy player destination`() {
+        assertThat(GuidePlaybackSelection.Live(CHANNEL_ID).toPlayerDestination())
+            .isEqualTo(AppDestination.Player(CHANNEL_ID))
+    }
+
+    @Test(expected = IllegalArgumentException::class)
+    fun `partial catchup tuple is rejected`() {
+        AppDestination.Player(
+            channelId = CHANNEL_ID,
+            programmeId = PROGRAMME_ID,
+            programmeStartEpochMillis = PROGRAMME_START,
+            programmeEndEpochMillis = null,
+        )
+    }
+
+    private companion object {
+        const val CHANNEL_ID = "channel-news"
+        const val PROGRAMME_ID = "gp1_00112233445566778899aabbccddeeff"
+        const val PROGRAMME_START = 1_800_000_000_000L
+        const val PROGRAMME_END = PROGRAMME_START + 3_600_000L
+    }
+}

catalog/api/src/main/kotlin/app/muxtv/catalog/PlaybackCatalog.kt

@@ -165,6 +165,23 @@ interface PlaybackCandidateResolver {
         profileId: String,
         candidate: PlaybackCandidateIdentity,
     ): PlaybackVariantResolution?
+
+    suspend fun resolveIntentCandidate(
+        profileId: String,
+        intent: PlaybackIntent,
+        candidate: PlaybackCandidateIdentity,
+    ): PlaybackVariantResolution? = when (intent) {
+        is PlaybackIntent.Live -> resolveCandidate(
+            profileId = profileId,
+            candidate = candidate,
+        )
+
+        is PlaybackIntent.CatchupProgram,
+        is PlaybackIntent.CatchupPosition,
+        -> PlaybackVariantResolution.AccessUnavailable(
+            PlaybackAccessUnavailableReason.ArchiveUnsupported,
+        )
+    }
 }
 
 interface PlaybackCatalog {

catalog/api/src/test/kotlin/app/muxtv/catalog/PlaybackCandidateResolverIntentTest.kt

@@ -0,0 +1,90 @@
+package app.muxtv.catalog
+
+import app.muxtv.player.PlaybackIntent
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+
+class PlaybackCandidateResolverIntentTest {
+    @Test
+    fun liveIntentDefaultsToExistingExactCandidateResolution(): Unit = runBlocking {
+        val candidate = PlaybackCandidateIdentity(
+            channelId = CHANNEL_ID,
+            variantId = VARIANT_ID,
+        )
+        val expected = PlaybackVariantResolution.AccessUnavailable(
+            PlaybackAccessUnavailableReason.CredentialUnavailable,
+        )
+        val resolvedCandidates = mutableListOf<PlaybackCandidateIdentity>()
+        val resolver = recordingResolver(resolvedCandidates, expected)
+
+        val result = resolver.resolveIntentCandidate(
+            profileId = PROFILE_ID,
+            intent = PlaybackIntent.Live(CHANNEL_ID),
+            candidate = candidate,
+        )
+
+        assertThat(result).isEqualTo(expected)
+        assertThat(resolvedCandidates).containsExactly(candidate)
+        Unit
+    }
+
+    @Test
+    fun archiveIntentDefaultsToUnsupportedWithoutFallingBackToLiveCandidateResolution(): Unit =
+        runBlocking {
+            val candidate = PlaybackCandidateIdentity(
+                channelId = CHANNEL_ID,
+                variantId = VARIANT_ID,
+            )
+            val resolvedCandidates = mutableListOf<PlaybackCandidateIdentity>()
+            val resolver = recordingResolver(
+                resolvedCandidates = resolvedCandidates,
+                resolution = PlaybackVariantResolution.AccessUnavailable(
+                    PlaybackAccessUnavailableReason.CredentialUnavailable,
+                ),
+            )
+
+            val result = resolver.resolveIntentCandidate(
+                profileId = PROFILE_ID,
+                intent = PlaybackIntent.CatchupPosition(
+                    channelId = CHANNEL_ID,
+                    positionEpochMillis = 1_800_000_000_000L,
+                ),
+                candidate = candidate,
+            )
+
+            assertThat(result).isEqualTo(
+                PlaybackVariantResolution.AccessUnavailable(
+                    PlaybackAccessUnavailableReason.ArchiveUnsupported,
+                ),
+            )
+            assertThat(resolvedCandidates).isEmpty()
+            Unit
+        }
+
+    private fun recordingResolver(
+        resolvedCandidates: MutableList<PlaybackCandidateIdentity>,
+        resolution: PlaybackVariantResolution,
+    ): PlaybackCandidateResolver = object : PlaybackCandidateResolver {
+        override suspend fun getCandidates(
+            profileId: String,
+            channelId: String,
+            preferredVariantId: String?,
+            limit: Int,
+        ): List<PlaybackCandidateIdentity> = emptyList()
+
+        override suspend fun resolveCandidate(
+            profileId: String,
+            candidate: PlaybackCandidateIdentity,
+        ): PlaybackVariantResolution {
+            resolvedCandidates += candidate
+            return resolution
+        }
+    }
+
+    private companion object {
+        const val PROFILE_ID = "profile-main"
+        const val CHANNEL_ID = "channel-news"
+        const val VARIANT_ID = "variant-primary"
+    }
+}