diff --git a/android/app/build.gradle.kts b/android/app/build.gradle.kts index 17719218..1568ea0b 100644 --- a/android/app/build.gradle.kts +++ b/android/app/build.gradle.kts @@ -9,8 +9,8 @@ android { applicationId = "tv.orbit.classic" minSdk = 26 targetSdk = 36 - versionCode = 253 - versionName = "0.108.93-zlib-subtitles" + versionCode = 254 + versionName = "0.108.94-catch-up-v2" } buildFeatures { compose = true } // The finished build for the TVs (Paul, 6 November 2026: the test build stuttered on the box). Not debuggable, so diff --git a/android/app/src/main/java/tv/orbit/classic/CatchUp.kt b/android/app/src/main/java/tv/orbit/classic/CatchUp.kt index 96a36fd1..55042165 100644 --- a/android/app/src/main/java/tv/orbit/classic/CatchUp.kt +++ b/android/app/src/main/java/tv/orbit/classic/CatchUp.kt @@ -10,6 +10,7 @@ import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.runtime.* import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusProperties import androidx.compose.ui.focus.focusRequester @@ -129,86 +130,208 @@ internal fun CatchUpCard(entry: CatchUpEntry, nowMs: Long, onWatch: () -> Unit, OrbitButton("Watch from the start", Modifier.focusRequester(watchFocus), onClick = onWatch) OrbitButton("Back", onClick = onDismiss) } - Text("While watching: ◄► skip 30 s OK pause ▲▼ back to live Back leave Catch Up", color = Muted, fontSize = 11.sp) + Text("While watching: ◄► skip 30 s OK pause Hold OK subtitles and options ▲▼ back to live", color = Muted, fontSize = 11.sp) } } } -/** The Catch Up tab on the top bar: the last two days in rows, newest first. */ +/** A row on the Catch Up page: Continue watching first, then the shelves. */ +private class CatchUpRow(val title: String, val entries: List, val carryOn: List? = null) + +/** What the page's filters leave: one channel, and words in the title. */ +internal fun catchUpMatches(entry: CatchUpEntry, channel: Int?, query: String): Boolean = + (channel == null || entry.channel.number == channel) && (query.isBlank() || entry.show.media.item.title.contains(query.trim(), ignoreCase = true)) + +/** + * The Catch Up tab on the top bar (v2, Paul, 7 November 2026: design/catch-up/v2): Continue watching first, then the last two + * days in rows, newest first, as picture cards. Above them, Search and a chip for each channel with something to catch up on. + * Held OK on a Continue watching card asks to take it off the row. + */ @Composable -internal fun CatchUpScreen(channels: List, modifier: Modifier = Modifier, onOpen: (CatchUpEntry) -> Unit) { +internal fun CatchUpScreen(channels: List, session: EmbySampleSession?, modifier: Modifier = Modifier, onOpen: (CatchUpEntry) -> Unit, + onResume: (ContinueEntry) -> Unit = {}) { var now by remember { mutableLongStateOf(System.currentTimeMillis()) } LaunchedEffect(Unit) { while (true) { delay(30_000); if (!FullScreen.active) now = System.currentTimeMillis() } } - val shelves = remember(channels, now / 60_000) { catchUpShelves(channels, now) } + var channelFilter by remember { mutableStateOf(null) } + var query by remember { mutableStateOf("") } + var searching by remember { mutableStateOf(false) } + var removing by remember { mutableStateOf(null) } + val allShelves = remember(channels, now / 60_000) { catchUpShelves(channels, now) } + val carryOn = remember(channels, now / 60_000, ContinueWatching.marks) { continueEntries(channels, ContinueWatching.marks, now) } + // The chips: a channel only when it has something here, in channel order. + val chipChannels = remember(allShelves) { allShelves.flatMap { it.entries }.map { it.channel }.distinctBy { it.number }.sortedBy { it.number } } + val rows = remember(allShelves, carryOn, channelFilter, query) { + val kept = carryOn.filter { catchUpMatches(it.entry, channelFilter, query) } + listOfNotNull(kept.takeIf { it.isNotEmpty() }?.let { CatchUpRow("CONTINUE WATCHING", it.map { c -> c.entry }, it) }) + + allShelves.map { CatchUpRow(it.title, it.entries.filter { e -> catchUpMatches(e, channelFilter, query) }) }.filter { it.entries.isNotEmpty() } + } + // Row -1 is the filter bar; its items are Search, All, then each channel. var row by remember { mutableIntStateOf(0) } - val columns = remember { mutableStateMapOf() } + var chip by remember { mutableIntStateOf(1) } + var okHeld by remember { mutableStateOf(false) } + val columns = remember { mutableStateMapOf() } val focus = remember { FocusRequester() } var focused by remember { mutableStateOf(false) } val nav = LocalNavFocus.current LaunchedEffect(Unit) { runCatching { focus.requestFocus() } } - Column(modifier.fillMaxWidth().background(Navy).padding(horizontal = 14.dp, vertical = 8.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { - Text("CATCH UP", color = CatchUpGreen, fontFamily = Anton, fontSize = 26.sp) - Text("Anything shown on Orbit in the last two days, from the start", color = Muted, fontSize = 14.sp) - if (shelves.isEmpty()) { - Text("Nothing to catch up on yet. Programmes appear here once they've aired.", color = Ink, fontSize = 16.sp, - modifier = Modifier.focusRequester(focus).focusProperties { if (nav != null) up = nav }.focusable()) - return@Column - } - val r = row.coerceIn(shelves.indices) - Column(Modifier.weight(1f).fillMaxWidth().focusRequester(focus).focusProperties { if (nav != null) up = nav }.onFocusChanged { focused = it.isFocused }.focusable().onPreviewKeyEvent { event -> + LaunchedEffect(searching, removing) { if (!searching && removing == null) runCatching { focus.requestFocus() } } + val chipCount = 2 + chipChannels.size + Column(modifier.fillMaxWidth().background(Navy).padding(horizontal = 14.dp, vertical = 8.dp).focusRequester(focus).focusProperties { if (nav != null) up = nav } + .onFocusChanged { focused = it.isFocused }.focusable().onPreviewKeyEvent { event -> val native = event.nativeKeyEvent + val r = row.coerceIn(-1, rows.lastIndex) + val isOk = native.keyCode == KeyEvent.KEYCODE_DPAD_CENTER || native.keyCode == KeyEvent.KEYCODE_ENTER + if (native.action == KeyEvent.ACTION_UP) { + if (!isOk) return@onPreviewKeyEvent false + if (okHeld) { okHeld = false; return@onPreviewKeyEvent true } + if (r == -1) when (val c = chip.coerceIn(0, chipCount - 1)) { + 0 -> searching = true + 1 -> { channelFilter = null; query = "" } + else -> channelFilter = chipChannels[c - 2].number.takeIf { it != channelFilter } + } else if (rows.isNotEmpty()) { + val shelf = rows[r]; val col = (columns[shelf.title] ?: 0).coerceIn(shelf.entries.indices) + shelf.carryOn?.let { onResume(it[col]) } ?: onOpen(shelf.entries[col]) + } + return@onPreviewKeyEvent true + } if (native.action != KeyEvent.ACTION_DOWN) return@onPreviewKeyEvent false - val col = (columns[r] ?: 0).coerceIn(shelves[r].entries.indices) + if (isOk) { + // Held on a Continue watching card: ask to take it off. + if (native.repeatCount > 0 && !okHeld && r >= 0 && rows.getOrNull(r)?.carryOn != null) { + okHeld = true + val shelf = rows[r]; removing = shelf.carryOn!![(columns[shelf.title] ?: 0).coerceIn(shelf.entries.indices)] + } + return@onPreviewKeyEvent true + } when (native.keyCode) { - // At the top row, up leaves for the top bar. - KeyEvent.KEYCODE_DPAD_UP -> if (r > 0) { row = r - 1; true } else false - KeyEvent.KEYCODE_DPAD_DOWN -> { if (r < shelves.lastIndex) row = r + 1; true } - KeyEvent.KEYCODE_DPAD_LEFT -> { columns[r] = (col - 1).coerceAtLeast(0); true } - KeyEvent.KEYCODE_DPAD_RIGHT -> { columns[r] = (col + 1).coerceAtMost(shelves[r].entries.lastIndex); true } - KeyEvent.KEYCODE_DPAD_CENTER, KeyEvent.KEYCODE_ENTER -> { if (native.repeatCount == 0) onOpen(shelves[r].entries[col]); true } + // At the filter bar, up leaves for the top bar. + KeyEvent.KEYCODE_DPAD_UP -> if (r > -1) { row = r - 1; true } else false + KeyEvent.KEYCODE_DPAD_DOWN -> { if (r < rows.lastIndex) row = r + 1; true } + KeyEvent.KEYCODE_DPAD_LEFT -> { if (r == -1) chip = (chip - 1).coerceAtLeast(0) else rows.getOrNull(r)?.let { columns[it.title] = ((columns[it.title] ?: 0) - 1).coerceAtLeast(0) }; true } + KeyEvent.KEYCODE_DPAD_RIGHT -> { if (r == -1) chip = (chip + 1).coerceAtMost(chipCount - 1) else rows.getOrNull(r)?.let { columns[it.title] = ((columns[it.title] ?: 0) + 1).coerceAtMost(it.entries.lastIndex) }; true } else -> false } - }, verticalArrangement = Arrangement.spacedBy(6.dp)) { - // Three rows at a time, moving with the cursor. - val first = (r - 1).coerceIn(0, (shelves.size - 3).coerceAtLeast(0)) - shelves.subList(first, minOf(first + 3, shelves.size)).forEachIndexed { offset, shelf -> + }, verticalArrangement = Arrangement.spacedBy(8.dp)) { + Row(verticalAlignment = Alignment.Bottom) { + Text("CATCH UP", color = CatchUpGreen, fontFamily = Anton, fontSize = 26.sp) + Spacer(Modifier.width(16.dp)) + Text("Everything on Orbit in the last two days, from the start", color = Muted, fontSize = 14.sp, modifier = Modifier.padding(bottom = 4.dp)) + } + // The filter bar. + val r = row.coerceIn(-1, rows.lastIndex) + Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) { + @Composable fun Chip(label: String, index: Int, chosen: Boolean) { + val on = focused && r == -1 && chip == index + Text(label, Modifier.background(if (chosen) Yellow else Panel, RoundedCornerShape(16.dp)).border(if (on) 3.dp else 0.dp, if (on) Ink else Color.Transparent, RoundedCornerShape(16.dp)) + .padding(horizontal = 14.dp, vertical = 5.dp), color = if (chosen) OnAccent else Ink, fontSize = 13.sp, fontWeight = FontWeight.SemiBold, maxLines = 1) + } + Chip(if (query.isBlank()) "⌕ Search" else "⌕ “${query.trim()}”", 0, query.isNotBlank()) + Chip("All", 1, channelFilter == null && query.isBlank()) + // The chips around the cursor, so a long list still fits. + val start = (chip - 2 - 3).coerceIn(0, (chipChannels.size - 7).coerceAtLeast(0)) + chipChannels.subList(start, minOf(start + 7, chipChannels.size)).forEachIndexed { k, ch -> Chip(ChannelBrands.displayName(ch), start + k + 2, channelFilter == ch.number) } + if (start + 7 < chipChannels.size) Text("›", color = Muted, fontSize = 16.sp) + } + if (rows.isEmpty()) { + Text(if (channelFilter != null || query.isNotBlank()) "Nothing here matches. Choose All to see everything." else "Nothing to catch up on yet. Programmes appear here once they've aired.", + color = Ink, fontSize = 16.sp) + } else Column(Modifier.weight(1f).fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(6.dp)) { + // Two rows at a time, moving with the cursor. + val first = r.coerceAtLeast(0).coerceIn(0, (rows.size - 2).coerceAtLeast(0)) + rows.subList(first, minOf(first + 2, rows.size)).forEachIndexed { offset, shelf -> val index = first + offset - val col = (columns[index] ?: 0).coerceIn(shelf.entries.indices) - Text(shelf.title, color = if (index == r) Yellow else Muted, fontSize = 13.sp, fontWeight = FontWeight.SemiBold) - val start = (col - 2).coerceIn(0, (shelf.entries.size - 5).coerceAtLeast(0)) - Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp)) { - shelf.entries.subList(start, minOf(start + 5, shelf.entries.size)).forEachIndexed { k, entry -> - CatchUpTile(entry, now, focused && index == r && start + k == col, Modifier.weight(1f)) + val col = (columns[shelf.title] ?: 0).coerceIn(shelf.entries.indices) + Text(shelf.title, color = if (index == r) Yellow else Muted, fontSize = 13.sp, fontWeight = FontWeight.SemiBold, letterSpacing = 1.sp) + val start = (col - 1).coerceIn(0, (shelf.entries.size - 4).coerceAtLeast(0)) + Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(10.dp)) { + shelf.entries.subList(start, minOf(start + 4, shelf.entries.size)).forEachIndexed { k, entry -> + CatchUpTile(entry, now, focused && index == r && start + k == col, session, shelf.carryOn?.get(start + k), Modifier.weight(1f)) } - repeat(5 - minOf(5, shelf.entries.size - start)) { Spacer(Modifier.weight(1f)) } + repeat(4 - minOf(4, shelf.entries.size - start)) { Spacer(Modifier.weight(1f)) } } } } - Text("▲▼ Rows ◄► Move OK Catch Up Back Home", color = Muted, fontSize = 11.sp) + Text(if (rows.getOrNull(r)?.carryOn != null) "OK Carry on watching Hold OK Remove ▲▼ Rows ◄► Move Back Home" + else if (r == -1) "OK Choose ◄► Move ▼ Programmes Back Home" else "OK Catch Up ▲▼ Rows ◄► Move Back Home", color = Muted, fontSize = 11.sp) + } + if (searching) CatchUpSearch(query, onDone = { query = it; searching = false; row = if (it.isBlank()) -1 else 0 }, onCancel = { searching = false }) + removing?.let { c -> + Dialog(onDismissRequest = { removing = null }, properties = DialogProperties(usePlatformDefaultWidth = false)) { + val corner = RoundedCornerShape(12.dp) + val removeFocus = remember { FocusRequester() } + LaunchedEffect(Unit) { runCatching { removeFocus.requestFocus() } } + Column(Modifier.width(520.dp).background(themed(Color(0xFF0A1E42)) { Deep }, corner).border(2.dp, Yellow, corner).padding(24.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { + Text("REMOVE FROM CONTINUE WATCHING?", color = Ink, fontFamily = Anton, fontSize = 22.sp) + Text(c.entry.show.media.item.title, color = Muted, fontSize = 14.sp, maxLines = 1, overflow = TextOverflow.Ellipsis) + Text("It stays in Catch Up until ${guideDayPrefix(c.entry.untilMs, now).trim().ifEmpty { "today" }} ${clock(c.entry.untilMs)}, from the start.", color = Muted, fontSize = 14.sp) + Spacer(Modifier.height(6.dp)) + Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) { + OrbitButton("Remove", Modifier.focusRequester(removeFocus)) { ContinueWatching.remove(c.entry.channel.number, c.entry.show.startMs); removing = null } + OrbitButton("Keep it") { removing = null } + } + } + } + } +} + +/** Search Catch Up by title, typed with the remote's keyboard. */ +@Composable +private fun CatchUpSearch(current: String, onDone: (String) -> Unit, onCancel: () -> Unit) { + var text by remember { mutableStateOf(current) } + Dialog(onDismissRequest = onCancel, properties = DialogProperties(usePlatformDefaultWidth = false)) { + val corner = RoundedCornerShape(12.dp) + val field = remember { FocusRequester() } + LaunchedEffect(Unit) { runCatching { field.requestFocus() } } + Column(Modifier.width(560.dp).background(themed(Color(0xFF0A1E42)) { Deep }, corner).border(2.dp, Yellow, corner).padding(24.dp), verticalArrangement = Arrangement.spacedBy(10.dp)) { + Text("SEARCH CATCH UP", color = CatchUpGreen, fontFamily = Anton, fontSize = 20.sp) + OrbitField(text, { text = it.take(60) }, "A programme's name", Modifier.fillMaxWidth().focusRequester(field)) + Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) { + OrbitButton("Search") { onDone(text) } + if (current.isNotBlank()) OrbitButton("Clear") { onDone("") } + OrbitButton("Back", onClick = onCancel) + } + } } } @Composable -private fun CatchUpTile(entry: CatchUpEntry, nowMs: Long, on: Boolean, modifier: Modifier) { - val corner = RoundedCornerShape(6.dp) +private fun CatchUpTile(entry: CatchUpEntry, nowMs: Long, on: Boolean, session: EmbySampleSession?, carryOn: ContinueEntry?, modifier: Modifier) { + val corner = RoundedCornerShape(8.dp) // Focused as on What's On: navy inside a gold ring, so the words stay crisp rather than washed out in gold. val ink = Ink - Column(modifier.height(92.dp).background(if (on) Navy else Panel, corner).border(if (on) 3.dp else 0.dp, if (on) Yellow else Color.Transparent, corner).padding(horizontal = 10.dp, vertical = 7.dp), verticalArrangement = Arrangement.spacedBy(2.dp)) { - Row(verticalAlignment = Alignment.CenterVertically) { + Column(modifier.background(if (on) Navy else Panel, corner).border(if (on) 3.dp else 0.dp, if (on) Yellow else Color.Transparent, corner)) { + Box(Modifier.fillMaxWidth().height(96.dp).clip(RoundedCornerShape(topStart = 8.dp, topEnd = 8.dp)).background(Deep)) { + val seriesId = remember(entry.channel, entry.show.startMs) { (entry.channel as? ScheduledChannel)?.seriesIdAt(entry.show.startMs) } + if (session != null) QueuedArtwork(session, entry.show.media.item.id, seriesId, Modifier.matchParentSize()) val mark = ChannelBrands.forNumber(entry.channel.number) - if (mark != null) Image(cachedPainter(mark.logo), mark.displayName, Modifier.logoPlate().width(60.dp).height(18.dp)) - else Text(ChannelBrands.displayName(entry.channel), color = ink, fontSize = 11.sp, maxLines = 1) - Spacer(Modifier.weight(1f)) - CatchUpMark() + Box(Modifier.padding(6.dp).background(Navy.copy(alpha = .8f), RoundedCornerShape(4.dp)).padding(horizontal = 5.dp, vertical = 3.dp)) { + if (mark != null) Image(cachedPainter(mark.logo), mark.displayName, Modifier.width(56.dp).height(16.dp)) + else Text(ChannelBrands.displayName(entry.channel), color = ink, fontSize = 11.sp, maxLines = 1) + } + if (carryOn != null) { + Text(leftLabel(carryOn.leftMs), Modifier.align(Alignment.BottomEnd).padding(6.dp).background(Navy.copy(alpha = .85f), RoundedCornerShape(10.dp)).padding(horizontal = 8.dp, vertical = 2.dp), + color = Ink, fontSize = 11.sp, fontWeight = FontWeight.SemiBold) + Box(Modifier.align(Alignment.BottomStart).fillMaxWidth().height(4.dp).background(Color.Black.copy(alpha = .5f))) { + Box(Modifier.fillMaxWidth(carryOn.fraction).fillMaxHeight().background(CatchUpGreen)) + } + } else Box(Modifier.align(Alignment.TopEnd).padding(6.dp)) { CatchUpMark() } + } + Column(Modifier.padding(horizontal = 10.dp, vertical = 6.dp), verticalArrangement = Arrangement.spacedBy(1.dp)) { + val (name, detail) = guideTitleParts(entry.show.media.item.title) + Text(name, color = ink, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, maxLines = 1, overflow = TextOverflow.Ellipsis) + Text(detail ?: "${entry.show.media.durationMs / 60_000} min", color = Muted, fontSize = 11.sp, maxLines = 1, overflow = TextOverflow.Ellipsis) + Text("${guideDayPrefix(entry.show.startMs, nowMs).trim().ifEmpty { "Ended" }.let { if (it == "Ended") "Ended ${clock(entry.show.endMs)}" else "$it ${clock(entry.show.startMs)}" }}", + color = if (on) Yellow else Muted, fontSize = 11.sp, maxLines = 1) } - val (name, detail) = guideTitleParts(entry.show.media.item.title) - Text(name, color = ink, fontSize = 14.sp, fontWeight = FontWeight.SemiBold, maxLines = 1, overflow = TextOverflow.Ellipsis) - Text(detail ?: "${entry.show.media.durationMs / 60_000} min", color = Muted, fontSize = 11.sp, maxLines = 1, overflow = TextOverflow.Ellipsis) - Text("${guideDayPrefix(entry.show.startMs, nowMs).trim().ifEmpty { "Ended" }.let { if (it == "Ended") "Ended ${clock(entry.show.endMs)}" else "$it ${clock(entry.show.startMs)}" }}", - color = if (on) Yellow else Muted, fontSize = 11.sp, maxLines = 1) } } +/** "17 min left", "1 h 12 min left". */ +internal fun leftLabel(leftMs: Long): String { + val minutes = (leftMs / 60_000).coerceAtLeast(1) + return if (minutes < 60) "$minutes min left" else "${minutes / 60} h${if (minutes % 60 > 0) " ${minutes % 60} min" else ""} left" +} + /** The badge in the corner while catching up. */ @Composable internal fun CatchUpBadge(modifier: Modifier = Modifier) { diff --git a/android/app/src/main/java/tv/orbit/classic/ContinueWatching.kt b/android/app/src/main/java/tv/orbit/classic/ContinueWatching.kt new file mode 100644 index 00000000..445e6e8a --- /dev/null +++ b/android/app/src/main/java/tv/orbit/classic/ContinueWatching.kt @@ -0,0 +1,75 @@ +package tv.orbit.classic + +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import org.json.JSONArray +import org.json.JSONObject +import java.io.File + +/** + * Continue watching (Paul, 7 November 2026): where you left a programme part-way, from Catch Up or live, so Catch Up can + * carry it on from there while it's still in Catch Up. One list per profile, on this box only. It only reads the plans. + */ +internal class ContinueMark(val number: Int, val startMs: Long, val itemId: String, val positionMs: Long, val durationMs: Long, val atMs: Long) { + fun toJson(): JSONObject = JSONObject().put("n", number).put("s", startMs).put("i", itemId).put("p", positionMs).put("d", durationMs).put("a", atMs) + companion object { + fun fromJson(o: JSONObject) = ContinueMark(o.getInt("n"), o.getLong("s"), o.getString("i").also { require(EmbyClient.validId(it)) }, + o.getLong("p").coerceAtLeast(0), o.getLong("d").coerceAtLeast(1), o.getLong("a")) + } +} + +/** Under this far in, it hasn't really been started. */ +internal const val CONTINUE_MIN_MS = 3 * 60_000L +/** Within this of the end, it counts as watched. */ +internal const val CONTINUE_END_MS = 5 * 60_000L +private const val CONTINUE_MAX = 20 + +/** + * [marks] after noting [positionMs] into [show] on [number]: a programme watched to its last few minutes leaves the list, + * one barely begun doesn't join it (a mark already there stays), anything else is kept as the latest place. + */ +internal fun notedMarks(marks: List, number: Int, show: SampleBroadcast, positionMs: Long, nowMs: Long): List { + val same = { m: ContinueMark -> m.number == number && m.startMs == show.startMs } + val duration = show.media.durationMs + return when { + positionMs >= duration - CONTINUE_END_MS -> marks.filterNot(same) + positionMs < CONTINUE_MIN_MS -> marks + else -> (marks.filterNot(same) + ContinueMark(number, show.startMs, show.media.item.id, positionMs, duration, nowMs)).sortedByDescending { it.atMs }.take(CONTINUE_MAX) + } +} + +/** A Continue watching card: the programme as Catch Up holds it, and where you were. */ +internal class ContinueEntry(val entry: CatchUpEntry, val positionMs: Long) { + val leftMs get() = (entry.show.media.durationMs - positionMs).coerceAtLeast(0) + val fraction get() = (positionMs.toFloat() / entry.show.media.durationMs).coerceIn(0f, 1f) +} + +/** + * The marks that can be carried on now: the programme has finished airing, is still in Catch Up, and its channel's plan still + * holds it. Newest first. + */ +internal fun continueEntries(channels: List, marks: List, nowMs: Long): List = + marks.sortedByDescending { it.atMs }.mapNotNull { m -> + val channel = channels.firstOrNull { it.number == m.number } as? ScheduledChannel ?: return@mapNotNull null + val e = channel.plan.entries.firstOrNull { it.startMs == m.startMs && it.media.item.id == m.itemId } ?: return@mapNotNull null + val show = SampleBroadcast(e.media, e.startMs, e.presentation) + if (!catchUpAvailable(channel, show, nowMs)) null else ContinueEntry(catchUpEntry(channel, show), m.positionMs) + } + +internal object ContinueWatching { + var marks by mutableStateOf>(emptyList()) + private set + private var file: File? = null + + fun load(scheduleDir: File, profile: String?) { + file = File(scheduleDir, "continue-${(profile ?: "all").filter { it.isLetterOrDigit() }.take(40)}.json") + marks = runCatching { JSONArray(file!!.readText()).let { a -> (0 until minOf(a.length(), CONTINUE_MAX)).mapNotNull { runCatching { ContinueMark.fromJson(a.getJSONObject(it)) }.getOrNull() } } }.getOrDefault(emptyList()) + } + fun note(number: Int, show: SampleBroadcast, positionMs: Long, nowMs: Long) { + val next = notedMarks(marks, number, show, positionMs, nowMs) + if (next != marks) { marks = next; save() } + } + fun remove(number: Int, startMs: Long) { marks = marks.filterNot { it.number == number && it.startMs == startMs }; save() } + private fun save() { runCatching { file?.writeText(JSONArray(marks.map { it.toJson() }).toString()) } } +} diff --git a/android/app/src/main/java/tv/orbit/classic/EmbyClient.kt b/android/app/src/main/java/tv/orbit/classic/EmbyClient.kt index 1a0193aa..ee1ff3bb 100644 --- a/android/app/src/main/java/tv/orbit/classic/EmbyClient.kt +++ b/android/app/src/main/java/tv/orbit/classic/EmbyClient.kt @@ -62,9 +62,9 @@ internal class HttpsEmbyTransport(internal val deviceId: String = UUID.randomUUI } /** The sign-in headers for this kind of server. */ internal fun authHeaders(token: String?): Map = when (kind) { - ServerKind.Emby -> mapOf("X-Emby-Authorization" to "Emby Client=\"Orbit TV\", Device=\"Orbit TV\", DeviceId=\"$deviceId\", Version=\"0.108.93\"") + + ServerKind.Emby -> mapOf("X-Emby-Authorization" to "Emby Client=\"Orbit TV\", Device=\"Orbit TV\", DeviceId=\"$deviceId\", Version=\"0.108.94\"") + (token?.let { mapOf("X-Emby-Token" to it) } ?: emptyMap()) - ServerKind.Jellyfin -> mapOf("Authorization" to "MediaBrowser Client=\"Orbit TV\", Device=\"Orbit TV\", DeviceId=\"$deviceId\", Version=\"0.108.93\"" + + ServerKind.Jellyfin -> mapOf("Authorization" to "MediaBrowser Client=\"Orbit TV\", Device=\"Orbit TV\", DeviceId=\"$deviceId\", Version=\"0.108.94\"" + (token?.let { ", Token=\"$it\"" } ?: "")) } /** One picture from the provider, or nothing. Same fixed origin and no redirects, and failures are never shown or logged. */ diff --git a/android/app/src/main/java/tv/orbit/classic/EmbyConnectionScreen.kt b/android/app/src/main/java/tv/orbit/classic/EmbyConnectionScreen.kt index db2a71cf..703a1f1e 100644 --- a/android/app/src/main/java/tv/orbit/classic/EmbyConnectionScreen.kt +++ b/android/app/src/main/java/tv/orbit/classic/EmbyConnectionScreen.kt @@ -366,6 +366,20 @@ internal fun EmbyConnectionScreen(modifier: Modifier = Modifier, visible: Boolea delay(5 * 60_000L) } } + // Continue watching (Paul, 7 November 2026): every half minute of watching notes where you are in the programme, live or + // catching up, for whoever's watching; Catch Up offers it back once it has aired. + LaunchedEffect(workspace, Profiles.current?.id) { withContext(Dispatchers.IO) { ContinueWatching.load(workspace.scheduleDir, Profiles.current?.id) } } + LaunchedEffect(session) { + while (true) { + delay(30_000) + if (!watchingChannel || selectedNumber == DRIVE_IN_NUMBER) continue + val channel = scheduledChannels[selectedNumber] ?: continue + val now = System.currentTimeMillis(); val at = now + channelClockOffset + val show = runCatching { channel.at(at) }.getOrNull() ?: continue + if (show.endMs - show.startMs < 10 * 60_000L) continue + runCatching { withContext(Dispatchers.IO) { ContinueWatching.note(channel.number, show, at - show.startMs, now) } } + } + } // A channel of your own whose first plan was cut short, picked up again (set by the round below, run once setSmartSchedule exists). var resumeNumber by remember { mutableStateOf(null) } // Keeps smart channels topped up in the background. A failure changes nothing on air. @@ -747,7 +761,8 @@ internal fun EmbyConnectionScreen(modifier: Modifier = Modifier, visible: Boolea val picture = @Composable { GuidePicture(liveSession, liveChannel, live = !watchingChannel, handoff = liveHandoff, onUnplayable = ::rememberUnplayable) } when { mainHome -> HomeScreen(availableChannels, modifier, onCategory = { guideCategory = it; onGuide() }) - mainCatchUp -> CatchUpScreen(availableChannels, modifier, onOpen = { catchUpOpen = it }) + mainCatchUp -> CatchUpScreen(availableChannels, liveSession, modifier, onOpen = { catchUpOpen = it }, + onResume = { c -> if (c.entry.show.startMs >= System.currentTimeMillis() - CATCH_UP_MS) tune(c.entry.channel.number, c.entry.show.startMs + c.positionMs - System.currentTimeMillis()) }) mainWhatsOn -> WhatsOnScreen(liveSession, scheduledChannels.filterKeys { !lockedOut(it) && !profileHides(it) }.mapValues { it.value.plan }, driveInPlan.takeIf { Profiles.current?.let { it.kind != ProfileKind.Kids || it.driveIn } ?: true }, modifier, reminders, onWatch = { tune(it, 0) }, onDriveIn = onDriveIn, onBack = onHome, diff --git a/android/app/src/main/java/tv/orbit/classic/EmbyPlaybackDialog.kt b/android/app/src/main/java/tv/orbit/classic/EmbyPlaybackDialog.kt index 993130c1..233914c0 100644 --- a/android/app/src/main/java/tv/orbit/classic/EmbyPlaybackDialog.kt +++ b/android/app/src/main/java/tv/orbit/classic/EmbyPlaybackDialog.kt @@ -368,7 +368,18 @@ internal fun EmbyPlaybackDialog(session: EmbySampleSession, plan: EmbyPlaybackPl // Number keys and a held OK open the box. A short OK still shows the programme bar. if (scheduled != null && event.action == KeyEvent.ACTION_DOWN) { if (isOk && event.repeatCount > 0 && numberEntry == null && !okHeld) { - okHeld = true; numberProblem = null; numberEntry = ChannelEntry.from(scheduled.channel.number) + okHeld = true; numberProblem = null + // Catching up, a held OK opens its options: ◄► skip there, so subtitles and sound live here (Paul, + // 7 November 2026), with starting again, a channel by number and back to live. + val catching = currentScheduled + if (catching?.catchingUp() == true) { + val rows = trackRows().filter { it.section != "Sleep timer" } + listOf( + TrackRow("Catch Up", "Start again", false) { shift(-player.currentPosition); player.seekTo(0); showInfo() }, + TrackRow("Catch Up", "Go to a channel…", false) { numberEntry = ChannelEntry.from(catching.channel.number) }, + TrackRow("Catch Up", "Back to live", false) { live(); player.seekTo(catching.programme.offsetAt(System.currentTimeMillis())); showInfo() }) + trackCursor = rows.indexOfFirst { it.selected }.coerceAtLeast(0) + trackMenu = rows + } else numberEntry = ChannelEntry.from(scheduled.channel.number) return@setOnKeyListener true } if (typedDigit != null && numberEntry == null) { numberProblem = null; numberEntry = ChannelEntry.from(scheduled.channel.number) } diff --git a/android/app/src/main/java/tv/orbit/classic/SecureMediaDataSource.kt b/android/app/src/main/java/tv/orbit/classic/SecureMediaDataSource.kt index 245cd5f2..dda5a77e 100644 --- a/android/app/src/main/java/tv/orbit/classic/SecureMediaDataSource.kt +++ b/android/app/src/main/java/tv/orbit/classic/SecureMediaDataSource.kt @@ -39,7 +39,7 @@ internal class SecureMediaDataSource(private val session: EmbySampleSession) : B next.instanceFollowRedirects = false next.connectTimeout = 10_000 next.readTimeout = 20_000 - next.setRequestProperty("User-Agent", "OrbitTV/0.108.93") + next.setRequestProperty("User-Agent", "OrbitTV/0.108.94") next.setRequestProperty("Accept-Encoding", "identity") session.mediaHeaders(address).forEach { (key, value) -> next.setRequestProperty(key, value) } if (dataSpec.position != 0L || dataSpec.length != C.LENGTH_UNSET.toLong()) { diff --git a/android/app/src/test/java/tv/orbit/classic/CatchUpTest.kt b/android/app/src/test/java/tv/orbit/classic/CatchUpTest.kt index 813349f8..5f652759 100644 --- a/android/app/src/test/java/tv/orbit/classic/CatchUpTest.kt +++ b/android/app/src/test/java/tv/orbit/classic/CatchUpTest.kt @@ -138,4 +138,37 @@ class CatchUpTest { SleepTimer.set(SleepChoice.AfterThis, now, null) assertEquals(SleepChoice.Off, SleepTimer.choice) } + + // Continue watching (Paul, 7 November 2026): where you left a programme, offered once it has aired, gone when watched. + @Test fun continueWatchingKeepsWhereYouLeftOff() { + val c = channel() + val e = c.plan.entries.last { it.endMs <= now - hour } + val show = SampleBroadcast(e.media, e.startMs, e.presentation) + var marks = notedMarks(emptyList(), c.number, show, 2 * minute, now) + assertTrue("barely begun doesn't count", marks.isEmpty()) + marks = notedMarks(marks, c.number, show, 20 * minute, now) + assertEquals(1, marks.size) + val carry = continueEntries(listOf(c), marks, now).single() + assertEquals(20 * minute, carry.positionMs); assertEquals(e.startMs, carry.entry.show.startMs) + assertEquals("25 min left", leftLabel(carry.leftMs)) + // Watched to the last few minutes: off the row. + assertTrue(notedMarks(marks, c.number, show, e.media.durationMs - 2 * minute, now).isEmpty()) + // Still airing, or gone from Catch Up: not offered. + val live = c.plan.entries.first { it.startMs <= now && it.endMs > now } + val liveMarks = notedMarks(emptyList(), c.number, SampleBroadcast(live.media, live.startMs, live.presentation), 10 * minute, now) + assertTrue(continueEntries(listOf(c), liveMarks, now).isEmpty()) + assertTrue(continueEntries(listOf(c), marks, e.startMs + CATCH_UP_MS + minute).isEmpty()) + assertEquals("1 h 12 min left", leftLabel(72 * minute)) + } + + @Test fun catchUpFiltersByChannelAndTitle() { + val c = channel() + val e = c.plan.entries.last { it.endMs <= now } + val entry = catchUpEntry(c, SampleBroadcast(e.media, e.startMs, e.presentation)) + val title = e.media.item.title + assertTrue(catchUpMatches(entry, null, "")) + assertTrue(catchUpMatches(entry, 106, title.take(6).lowercase())) + assertFalse(catchUpMatches(entry, 107, "")) + assertFalse(catchUpMatches(entry, null, "Twin Peaks")) + } }