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 3fb55ff2..ed5f7587 100644 --- a/android/app/src/main/java/tv/orbit/classic/EmbyClient.kt +++ b/android/app/src/main/java/tv/orbit/classic/EmbyClient.kt @@ -226,7 +226,7 @@ internal class EmbyClient(private val transport: EmbyTransport = HttpsEmbyTransp 403 -> throw EmbyCheckException("The provider did not permit this connection or library request.", status) 429 -> throw EmbyCheckException("The provider asked us to slow down. Wait before trying again.", status) in 300..399 -> throw EmbyCheckException("The provider redirected the request. The login was not forwarded to another address.") - else -> throw EmbyCheckException("The provider could not complete this check (HTTP $status).", retryable = status >= 500) + else -> throw EmbyCheckException("The provider could not complete this check (HTTP $status).", status, retryable = status >= 500) } } } diff --git a/android/app/src/main/java/tv/orbit/classic/EmbyPlaybackProtocol.kt b/android/app/src/main/java/tv/orbit/classic/EmbyPlaybackProtocol.kt index 6d22d956..15927a20 100644 --- a/android/app/src/main/java/tv/orbit/classic/EmbyPlaybackProtocol.kt +++ b/android/app/src/main/java/tv/orbit/classic/EmbyPlaybackProtocol.kt @@ -496,6 +496,21 @@ internal class EmbySampleSession(private val transport: EmbyTransport, private v fun fetchArtwork(path: String): ByteArray? = (transport as? HttpsEmbyTransport)?.fetchImage(path, currentToken()) fun rememberScheduledItems(items: List) { channelEpisodes = channelEpisodes + items.associateBy { it.id } } + /** + * A booked film the library no longer has under its number (Paul, 12 November 2026: Scream 2 on the new server, whose + * first scan re-files titles). One search for the same title, matched exactly as a channel's list is; null when there's + * no copy, or only the one that's gone. + */ + fun refiledFilm(item: SampleItem): ScheduledMedia? { + if (item.type != "Movie") return null + val film = findFilm(transport, userId, ::currentToken, item.title, BoxDecoders::canDecode).film ?: return null + if (film.id == item.id) return null + val copy = film.episodes.first() + val found = SampleItem(film.title, "Movie", copy.durationMs / 60_000, "", copy.id, copy.durationMs) + rememberScheduledItems(listOf(found)) + return ScheduledMedia(found, copy.sourceId, copy.durationMs) + } + fun checkMetadataCoverage(checkActive: () -> Unit = {}): List = auditMetadataCoverage(transport, userId, ::currentToken, checkActive) fun importCatalogue(sink: CatalogueSink, maxPages: Int = CATALOGUE_PAGES_PER_RUN, pause: () -> Unit = {}, checkActive: () -> Unit = {}, onPage: () -> Unit = {}, diff --git a/android/app/src/main/java/tv/orbit/classic/GuidePicture.kt b/android/app/src/main/java/tv/orbit/classic/GuidePicture.kt index c98aafac..449d4390 100644 --- a/android/app/src/main/java/tv/orbit/classic/GuidePicture.kt +++ b/android/app/src/main/java/tv/orbit/classic/GuidePicture.kt @@ -143,8 +143,8 @@ private fun GuideLiveProgramme(session: EmbySampleSession, channel: SampleChanne LaunchedEffect(Unit) { if (returned != null) return@LaunchedEffect try { - val opened = withContext(Dispatchers.IO) { session.prepareForTuning(programme.media.item, programme.media.sourceId) { Thread.sleep(2_000) } } - val fit = runtimeFit(opened, programme) + val (opened, booked) = withContext(Dispatchers.IO) { openBooked(session, channel, Workspaces.current(context).schedules, programme, live = true) } + val fit = runtimeFit(opened, booked) // A longer file makes room for itself here too, so the picture and full screen agree (ProgrammeLengths.kt). if (fit == RuntimeFit.Adjust) opened.durationMs?.let { actual -> withContext(Dispatchers.IO) { PlanEdits.retime(channel, Workspaces.current(context).schedules, session.accountId, programme.startMs, actual) } diff --git a/android/app/src/main/java/tv/orbit/classic/ProgrammeLengths.kt b/android/app/src/main/java/tv/orbit/classic/ProgrammeLengths.kt index a6708592..d1cff6e1 100644 --- a/android/app/src/main/java/tv/orbit/classic/ProgrammeLengths.kt +++ b/android/app/src/main/java/tv/orbit/classic/ProgrammeLengths.kt @@ -96,6 +96,24 @@ internal fun retimedPlan(plan: ChannelPlan, startMs: Long, actualMs: Long): Chan return plan.copy(entries = entries) } +/** + * Opens a booked programme. A film the server answers for with an error because its number has gone (404, or Emby's 500 + * for an item it no longer has) is looked for once by title; the copy found plays in the same slot, and on a live channel + * the schedule is updated to it, so the guide and every screen agree. Returns the plan and the programme as now booked. + */ +internal fun openBooked(session: EmbySampleSession, channel: SampleChannel, store: ScheduleStore, show: SampleBroadcast, live: Boolean, ahead: Boolean = false): Pair { + try { return session.prepareForTuning(show.media.item, show.media.sourceId, ahead) { Thread.sleep(2_000) } to show } + catch (failure: EmbyCheckException) { + if (failure.httpStatus != 404 && failure.httpStatus != 500) throw failure + val found = session.refiledFilm(show.media.item) ?: throw failure + android.util.Log.i("OrbitSchedule", "channel=${channel.number} refiled old=${show.media.item.id} new=${found.item.id}") + if (live) PlanEdits.replace(channel, store, session.accountId, show.startMs, show.media.item.id, found) + // Booked in the old slot; the length check that follows then re-times it for the copy's own length. + val booked = show.copy(media = found.copy(durationMs = show.media.durationMs), fileMs = null) + return session.prepareForTuning(found.item, found.sourceId, ahead) { Thread.sleep(2_000) } to booked + } +} + /** Every change to a saved plan goes through this, so a top-up and a re-timing never write over each other. */ internal object PlanEdits { val lock = Any() @@ -106,6 +124,21 @@ internal object PlanEdits { * screen (guide, What's On, the Companion, the player) reads the same plan, so they all move together. Returns how many * programmes moved. */ + /** Puts [found] in place of the booked file [oldId] at [startMs], keeping its slot (see [openBooked]). */ + fun replace(channel: SampleChannel, store: ScheduleStore, userId: String, startMs: Long, oldId: String, found: ScheduledMedia) { + if (channel !is ScheduledChannel || channel.number == DRIVE_IN_NUMBER) return + synchronized(lock) { + val saved = store.loadPlan(userId, channel.number) ?: return + val at = saved.entries.indexOfFirst { it.startMs == startMs && it.media.item.id == oldId }.takeIf { it >= 0 } ?: return + val entry = saved.entries[at] + val slot = entry.media.durationMs + val media = found.copy(durationMs = slot, item = found.item.copy(minutes = slot / 60_000, durationMs = slot)) + val updated = saved.copy(entries = saved.entries.toMutableList().also { it[at] = entry.copy(media = media, fileMs = null) }) + store.savePlan(userId, channel.number, updated) + channel.plan = updated + } + } + fun retime(channel: SampleChannel, store: ScheduleStore, userId: String, startMs: Long, actualMs: Long): Int { if (channel !is ScheduledChannel || channel.number == DRIVE_IN_NUMBER) return 0 synchronized(lock) { diff --git a/android/app/src/main/java/tv/orbit/classic/SampleChannelScreens.kt b/android/app/src/main/java/tv/orbit/classic/SampleChannelScreens.kt index 82f6745c..6522cb13 100644 --- a/android/app/src/main/java/tv/orbit/classic/SampleChannelScreens.kt +++ b/android/app/src/main/java/tv/orbit/classic/SampleChannelScreens.kt @@ -138,14 +138,16 @@ internal fun ScheduledChannelPlayer(session: EmbySampleSession, channel: SampleC val tuneStarted = android.os.SystemClock.elapsedRealtime() // Got ready ahead (TuneAhead) when it's a channel either side, or a guide row rested on. val ahead = if (clockOffsetMs == 0L) TuneAhead.take(session, current.media.item, current.media.sourceId) else null + // A film the scan has re-filed under a new number is found again once (openBooked). + var booked = current val plan = ahead ?: prepareMutex.withLock { withContext(Dispatchers.IO) { - session.prepareForTuning(current.media.item, current.media.sourceId) { Thread.sleep(2_000) } + openBooked(session, channel, schedules, current, live = clockOffsetMs == 0L).also { booked = it.second }.first } } android.util.Log.i("OrbitSchedule", "channel=${channel.number} tunePrepareMs=${android.os.SystemClock.elapsedRealtime() - tuneStarted} ahead=${ahead != null}") // A different length plays like a real network's would (ProgrammeLengths.kt); only a file that isn't the one booked is skipped. - val fit = runtimeFit(plan, current) + val fit = runtimeFit(plan, booked) if (fit == RuntimeFit.Refuse) throw EmbyCheckException("This programme's runtime changed. Return and rebuild the sample channel.") // Live only: Catch Up replays the past, which mustn't move what's on now. if (fit == RuntimeFit.Adjust && clockOffsetMs == 0L) plan.durationMs?.let { actual -> diff --git a/android/app/src/test/java/tv/orbit/classic/ProgrammeLengthsTest.kt b/android/app/src/test/java/tv/orbit/classic/ProgrammeLengthsTest.kt index eaf2c720..d4b98584 100644 --- a/android/app/src/test/java/tv/orbit/classic/ProgrammeLengthsTest.kt +++ b/android/app/src/test/java/tv/orbit/classic/ProgrammeLengthsTest.kt @@ -137,6 +137,29 @@ class ProgrammeLengthsTest { assertNull(retimedPlan(once, 0, 101 * min)) } + @Test + fun aRefiledFilmTakesTheSameSlotAndIsThenTimedForItsOwnLength() { + // 12 November 2026: the scan re-filed Scream 2 under a new number. The copy found keeps the slot, then re-times. + val dir = kotlin.io.path.createTempDirectory("refiled").toFile() + try { + val store = ScheduleStore(dir) + val p = plan(entry("old1", 0, 120 * min), entry("next1", 120 * min, 30 * min)) + store.savePlan("u1", 304, p) + val channel = ScheduledChannel(SampleChannel(listOf(entry("loop1", 0, 30 * min).media, entry("loop2", 0, 30 * min).media), "Horror", 304), p) + val copy = entry("new1", 0, 120 * min + 14_000).media + PlanEdits.replace(channel, store, "u1", 0, "old1", copy) + assertEquals("new1", channel.plan.entries[0].media.item.id) + assertEquals(120 * min, channel.plan.entries[0].media.durationMs) + assertEquals("new1", store.loadPlan("u1", 304)!!.entries[0].media.item.id) + // Then its own length: 14 seconds longer, so what follows moves. + assertEquals(1, PlanEdits.retime(channel, store, "u1", 0, 120 * min + 14_000)) + assertEquals(120 * min + 14_000, channel.plan.entries[1].startMs) + // A different booked file at that time is left alone. + PlanEdits.replace(channel, store, "u1", 0, "someoneelse", entry("x1", 0, min).media) + assertEquals("new1", channel.plan.entries[0].media.item.id) + } finally { dir.deleteRecursively() } + } + @Test fun aReTimedPlanSavesAndLoads() { val dir = kotlin.io.path.createTempDirectory("lengths").toFile()