0.108.33: the After Dark lock

Paul, 5 November 2026: the first of first-run setup, with children on the
TV. Settings > After Dark lock sets a four-digit PIN (dialled or typed,
entered twice). With a PIN set, Orbit After Dark and The Late Show at the
Drive-In are hidden from the guide, Home, What's On, Catch Up, channel up
and down and the number box; if it locks while on After Dark, Orbit goes
to the first channel. Entering the PIN unlocks them until Orbit closes,
when they lock again. Changing the PIN or turning the lock off needs the
PIN; signing out clears it. The PIN is kept only as a salted SHA-256 hash.
After Dark also leaves the Pairs cards. Loaded before anything is drawn.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
2026-11-05 22:53:05 +00:00
co-authored by Claude Opus 5.5
parent d795b5fb56
commit ffddf55b44
12 changed files with 206 additions and 11 deletions
+2 -2
View File
@@ -9,8 +9,8 @@ android {
applicationId = "tv.orbit.classic"
minSdk = 26
targetSdk = 36
versionCode = 192
versionName = "0.108.32-skydoku-regions"
versionCode = 193
versionName = "0.108.33-after-dark-lock"
}
buildFeatures { compose = true }
compileOptions { sourceCompatibility = JavaVersion.VERSION_17; targetCompatibility = JavaVersion.VERSION_17 }
@@ -0,0 +1,158 @@
package tv.orbit.classic
import android.content.Context
import android.view.KeyEvent
import androidx.activity.compose.BackHandler
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.focusable
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.input.key.onPreviewKeyEvent
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.tv.material3.Text
/**
* The After Dark lock (Paul, 5 November 2026: the first of first-run setup, with children using the TV). Once a four-digit PIN
* is set, Orbit After Dark and The Late Show at the Drive-In are hidden everywhere: the guide, Home, What's On, Catch Up, channel
* up and down and the number box. Entering the PIN in Settings unlocks them until Orbit closes; it locks again by itself. The
* PIN is kept only as a salted hash on this box. Changing it or turning the lock off needs the PIN.
*/
internal const val PIN_LENGTH = 4
/** The channels the lock hides. */
internal val LockedChannels = setOf(AFTER_DARK_NUMBER)
internal object AfterDarkLock {
/** A PIN has been set on this box. */
var pinSet by mutableStateOf(false)
private set
/** Unlocked with the PIN, until Orbit closes. */
var unlocked by mutableStateOf(false)
private set
val locked get() = pinSet && !unlocked
fun load(context: Context) { pinSet = prefs(context).getString("after_dark_pin", null) != null }
private fun prefs(context: Context) = context.getSharedPreferences("orbit_lock", Context.MODE_PRIVATE)
fun check(context: Context, pin: String): Boolean {
val p = prefs(context)
val salt = p.getString("after_dark_salt", null) ?: return false
return p.getString("after_dark_pin", null) == pinHash(salt, pin)
}
fun set(context: Context, pin: String) {
val salt = java.util.UUID.randomUUID().toString()
prefs(context).edit().putString("after_dark_salt", salt).putString("after_dark_pin", pinHash(salt, pin)).apply()
pinSet = true; unlocked = false
}
fun clear(context: Context) { prefs(context).edit().clear().apply(); pinSet = false; unlocked = false }
fun unlock(context: Context, pin: String) = check(context, pin).also { if (it) unlocked = true }
fun lock() { unlocked = false }
}
internal fun pinHash(salt: String, pin: String): String =
java.security.MessageDigest.getInstance("SHA-256").digest("$salt:$pin".toByteArray()).joinToString("") { "%02x".format(it) }
/** Hidden by the lock: the channel itself, or a Drive-In bill that's The Late Show. */
internal fun lockedOut(number: Int, locked: Boolean = AfterDarkLock.locked) = locked && number in LockedChannels
internal fun lockedOut(bill: DriveInBill, locked: Boolean = AfterDarkLock.locked) = locked && bill.kind == DriveInKind.LateShow
/**
* Four digits, dialled with up and down (the Xiaomi remote may have no number keys) or typed. Earlier digits show as dots.
* OK or right moves on; OK on the last submits. Back cancels.
*/
@Composable
internal fun PinEntry(title: String, problem: String?, onDone: (String) -> Unit, onCancel: () -> Unit) {
var entry by remember { mutableStateOf(ChannelEntry(List(PIN_LENGTH) { 0 })) }
val focus = remember { FocusRequester() }
LaunchedEffect(Unit) { focus.requestFocus() }
LaunchedEffect(problem) { if (problem != null) entry = ChannelEntry(List(PIN_LENGTH) { 0 }) }
BackHandler(onBack = onCancel)
fun submit(e: ChannelEntry) = onDone(e.digits.joinToString(""))
val corner = RoundedCornerShape(8.dp)
Column(Modifier.background(Navy, corner).border(2.dp, Yellow, corner).padding(horizontal = 22.dp, vertical = 14.dp).focusRequester(focus).focusable().onPreviewKeyEvent { event ->
val native = event.nativeKeyEvent
val typed = if (native.keyCode in KeyEvent.KEYCODE_0..KeyEvent.KEYCODE_9) native.keyCode - KeyEvent.KEYCODE_0 else null
val ok = native.keyCode == KeyEvent.KEYCODE_DPAD_CENTER || native.keyCode == KeyEvent.KEYCODE_ENTER
// On release, so the press that submits can't also act on what's behind.
if (native.action == KeyEvent.ACTION_UP) {
if (ok || native.keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) { if (entry.onLastSlot) { if (ok) submit(entry) } else entry = entry.next() }
return@onPreviewKeyEvent ok || native.keyCode == KeyEvent.KEYCODE_DPAD_RIGHT
}
when {
native.keyCode == KeyEvent.KEYCODE_DPAD_UP -> entry = entry.dial(1)
native.keyCode == KeyEvent.KEYCODE_DPAD_DOWN -> entry = entry.dial(-1)
native.keyCode == KeyEvent.KEYCODE_DPAD_LEFT -> entry = entry.previous()
typed != null -> { val next = entry.type(typed); if (entry.onLastSlot) submit(next) else entry = next }
ok || native.keyCode == KeyEvent.KEYCODE_DPAD_RIGHT -> {}
else -> return@onPreviewKeyEvent false
}
true
}, horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(8.dp)) {
Text(title, color = Color.White, fontSize = 16.sp, fontWeight = FontWeight.SemiBold)
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
entry.digits.forEachIndexed { i, d ->
Box(Modifier.size(40.dp, 46.dp).background(if (i == entry.slot) Yellow else Panel, RoundedCornerShape(4.dp)), contentAlignment = Alignment.Center) {
Text(if (i == entry.slot) d.toString() else if (i < entry.slot) "•" else "", color = if (i == entry.slot) Navy else Color.White, fontSize = 22.sp, fontWeight = FontWeight.SemiBold)
}
}
}
Text(problem ?: "▲▼ Change OK Next Back Cancel", color = if (problem != null) Yellow else Muted, fontSize = 11.sp)
}
}
private enum class LockStep { None, Unlock, NewPin, ConfirmPin, CheckForChange, CheckForOff }
/** Settings › After Dark lock. */
@Composable
internal fun LockDetail(firstSwitch: FocusRequester, modifier: Modifier) {
val context = LocalContext.current
var step by remember { mutableStateOf(LockStep.None) }
var first by remember { mutableStateOf("") }
var problem by remember { mutableStateOf<String?>(null) }
var note by remember { mutableStateOf<String?>(null) }
fun begin(s: LockStep) { step = s; problem = null; note = null }
Column(modifier, verticalArrangement = Arrangement.spacedBy(8.dp)) {
Text(when {
!AfterDarkLock.pinSet -> "Off: After Dark and The Late Show are showing"
AfterDarkLock.unlocked -> "Unlocked until Orbit closes"
else -> "Locked: After Dark and The Late Show are hidden"
}, color = Color.White, fontSize = 18.sp, fontWeight = FontWeight.SemiBold)
Text("With a PIN set, Orbit After Dark and The Late Show at the Drive-In are hidden from the guide, Home, What's On and Catch Up, and from channel up and down. " +
"Enter the PIN here to watch them; they lock again when Orbit closes.", color = Muted, fontSize = 12.sp)
note?.let { Text(it, color = Yellow, fontSize = 13.sp) }
when (step) {
LockStep.None -> Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
if (!AfterDarkLock.pinSet) OrbitButton("Set a PIN", Modifier.focusRequester(firstSwitch), onClick = { begin(LockStep.NewPin) })
else {
if (AfterDarkLock.unlocked) OrbitButton("Lock now", Modifier.focusRequester(firstSwitch), onClick = { AfterDarkLock.lock(); note = "Locked." })
else OrbitButton("Unlock until Orbit closes", Modifier.focusRequester(firstSwitch), onClick = { begin(LockStep.Unlock) })
OrbitButton("Change PIN", onClick = { begin(LockStep.CheckForChange) })
OrbitButton("Turn the lock off", onClick = { begin(LockStep.CheckForOff) })
}
}
LockStep.Unlock -> PinEntry("Enter the PIN", problem, onDone = { pin ->
if (AfterDarkLock.unlock(context, pin)) { step = LockStep.None; note = "Unlocked until Orbit closes." } else problem = "That's not the PIN"
}, onCancel = { step = LockStep.None })
LockStep.CheckForChange, LockStep.CheckForOff -> PinEntry("Enter the current PIN", problem, onDone = { pin ->
if (!AfterDarkLock.check(context, pin)) problem = "That's not the PIN"
else if (step == LockStep.CheckForOff) { AfterDarkLock.clear(context); step = LockStep.None; note = "The lock is off." }
else begin(LockStep.NewPin)
}, onCancel = { step = LockStep.None })
LockStep.NewPin -> key(step) { PinEntry("Choose a four-digit PIN", null, onDone = { pin -> first = pin; begin(LockStep.ConfirmPin) }, onCancel = { step = LockStep.None }) }
LockStep.ConfirmPin -> key(step) { PinEntry("Enter it again", problem, onDone = { pin ->
if (pin == first) { AfterDarkLock.set(context, pin); step = LockStep.None; note = "PIN set. After Dark and The Late Show are now locked." }
else { step = LockStep.NewPin; note = "Those didn't match. Choose it again." }
}, onCancel = { step = LockStep.None }) }
}
Text("Forgotten the PIN? Signing out in Emby account clears it, along with this box's schedules.", color = Muted, fontSize = 11.sp)
}
}
@@ -66,7 +66,8 @@ internal data class PairsGame(val cards: List<Int>, val matched: Set<Int> = empt
}
/** The ten channels whose logos make the pairs. */
private val PairsChannels = listOf(101, 102, 201, 203, 301, AFTER_DARK_NUMBER, 309, 401, 601, 612)
// A family game, so After Dark isn't among the cards.
private val PairsChannels = listOf(101, 102, 201, 203, 301, 302, 309, 401, 601, 612)
private val Marquee = FontFamily(Font(R.font.anton_regular))
private val Honey = Color(0xFFFFD84A)
@@ -346,7 +346,7 @@ internal fun DriveInScreen(session: EmbySampleSession, plan: ChannelPlan?, visit
var now by remember { mutableLongStateOf(System.currentTimeMillis()) }
LaunchedEffect(Unit) { while (true) { delay(1000); if (!FullScreen.active) now = System.currentTimeMillis() } }
val minute = now / 60_000
val bills = remember(plan, minute) { plan?.let { driveInBills(it).filter { bill -> bill.endMs > now } }.orEmpty().take(DRIVE_IN_LISTED) }
val bills = remember(plan, minute, AfterDarkLock.locked) { plan?.let { driveInBills(it).filter { bill -> bill.endMs > now && !lockedOut(bill) } }.orEmpty().take(DRIVE_IN_LISTED) }
var chosen by remember(visit) { mutableStateOf<Long?>(null) }
val selected = bills.firstOrNull { it.startMs == chosen } ?: bills.firstOrNull()
val index = bills.indexOf(selected)
@@ -66,7 +66,7 @@ internal class HttpsEmbyTransport(internal val deviceId: String = UUID.randomUUI
connection.connectTimeout = 10_000
connection.readTimeout = request.readTimeoutMs ?: if (request.path == "/Sessions/Logout") 5_000 else 15_000
connection.setRequestProperty("Accept", "application/json")
connection.setRequestProperty("X-Emby-Authorization", "Emby Client=\"Orbit TV\", Device=\"Orbit TV\", DeviceId=\"$deviceId\", Version=\"0.108.32\"")
connection.setRequestProperty("X-Emby-Authorization", "Emby Client=\"Orbit TV\", Device=\"Orbit TV\", DeviceId=\"$deviceId\", Version=\"0.108.33\"")
request.token?.let { connection.setRequestProperty("X-Emby-Token", it) }
if (request.method == "POST") {
val bytes = request.body.orEmpty().toByteArray(Charsets.UTF_8)
@@ -352,7 +352,13 @@ internal fun EmbyConnectionScreen(modifier: Modifier = Modifier, visible: Boolea
val active = session ?: return
scope.launch(Dispatchers.IO) { runCatching { scheduler.markFailed(active.accountId, itemId) } }
}
// The After Dark lock hides its channels from everything that lists or steps through channels, Catch Up included.
val availableChannels = availableSampleChannels(channel?.let(::onAir), afterDarkChannel?.let(::onAir), toonamiChannel?.let(::onAir), *extraChannels.map(::onAir).toTypedArray())
.filterNot { lockedOut(it.number) }
// Locked while on After Dark: back to the first channel, and out of full screen.
LaunchedEffect(AfterDarkLock.locked) {
if (AfterDarkLock.locked && lockedOut(selectedNumber)) { watchingChannel = false; channelClockOffset = 0; selectedNumber = availableChannels.firstOrNull()?.number ?: 101 }
}
val liveChannel = availableChannels.firstOrNull { it.number == selectedNumber }
if (mainDriveIn && liveSession != null) {
val booked = driveInPlan
@@ -403,7 +409,7 @@ internal fun EmbyConnectionScreen(modifier: Modifier = Modifier, visible: Boolea
when {
mainHome -> HomeScreen(availableChannels, modifier, onCategory = { guideCategory = it; onGuide() })
mainCatchUp -> CatchUpScreen(availableChannels, modifier, onOpen = { catchUpOpen = it })
mainWhatsOn -> WhatsOnScreen(liveSession, scheduledChannels.mapValues { it.value.plan }, driveInPlan, modifier, reminders,
mainWhatsOn -> WhatsOnScreen(liveSession, scheduledChannels.filterKeys { !lockedOut(it) }.mapValues { it.value.plan }, driveInPlan, modifier, reminders,
onWatch = { tune(it, 0) }, onDriveIn = onDriveIn, onBack = onHome,
onRemind = { item -> saveReminders(liveReminders(reminders, System.currentTimeMillis()) + ProgrammeReminder(item.channel, item.startMs, item.title)) })
else -> GuideGrid(channelsIn(guideCategory, availableChannels).ifEmpty { availableChannels }, selectedNumber, modifier, guideCategory, homeCategories(availableChannels.map { it.number }), picture,
@@ -542,7 +548,7 @@ internal fun EmbyConnectionScreen(modifier: Modifier = Modifier, visible: Boolea
decision == "deferred" -> "${idea.theme} deferred: it can come back in four weeks."
else -> "${idea.theme} dismissed: it won't be proposed again unless its films change." }
} }) }, isOn = { scheduledChannels.containsKey(it) }, onSwitch = { programming, on -> setSmartSchedule(programming, on) }, onSuggestions = { openSuggestions(it) },
onSignOut = { job?.cancel(); closeSession(forget = true) }, windingDown = windingDown, onWindDown = { on ->
onSignOut = { job?.cancel(); closeSession(forget = true); AfterDarkLock.clear(appContext) }, windingDown = windingDown, onWindDown = { on ->
val tots = scheduledChannels[TOTS_NUMBER]
val active = session
if (tots != null && active != null) scope.launch(Dispatchers.IO) {
@@ -58,6 +58,8 @@ class MainActivity : ComponentActivity() {
intent?.getStringExtra("orbit_play_test")?.takeIf(EmbyClient::validId)?.let { item ->
startActivity(android.content.Intent(this, PlaybackTestActivity::class.java).putExtra(PlaybackTestActivity.ITEM, item))
}
// Before anything is drawn, so a locked After Dark never shows for a moment.
AfterDarkLock.load(this)
// One typeface everywhere, matching the channel logos.
setContent { MaterialTheme { CompositionLocalProvider(androidx.tv.material3.LocalTextStyle provides androidx.compose.ui.text.TextStyle(fontFamily = Barlow)) { OrbitApp() } } }
}
@@ -107,7 +109,7 @@ private fun OrbitApp() {
// Opening the app always lands on the main menu, wherever it was left.
if (event == Lifecycle.Event.ON_STOP && realChannelAvailable && section != "Connect Emby") section = "Home"
// The sleep timer is for this evening's viewing only.
if (event == Lifecycle.Event.ON_STOP) SleepTimer.clear()
if (event == Lifecycle.Event.ON_STOP) { SleepTimer.clear(); AfterDarkLock.lock() }
}
lifecycle.addObserver(observer)
onDispose { lifecycle.removeObserver(observer) }
@@ -33,7 +33,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.32")
next.setRequestProperty("User-Agent", "OrbitTV/0.108.33")
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()) {
@@ -111,6 +111,7 @@ internal enum class SettingsSection(val label: String, val icon: Int) {
Viewing("Watching", R.drawable.orbit_icon_entertainment),
Arrivals("New arrivals", R.drawable.orbit_icon_movies),
Director("Director's Chair", R.drawable.orbit_icon_entertainment),
Lock("After Dark lock", R.drawable.orbit_icon_profile),
Account("Emby account", R.drawable.orbit_icon_profile),
}
@@ -286,6 +287,7 @@ internal fun SettingsScreen(section: SettingsSection, onSection: (SettingsSectio
SettingsSection.Viewing -> ViewingDetail(isOn(TOTS_NUMBER), windingDown, onWindDown, firstSwitch, detail)
SettingsSection.Arrivals -> arrivals(detail, firstSwitch)
SettingsSection.Director -> director(detail, firstSwitch)
SettingsSection.Lock -> LockDetail(firstSwitch, detail)
SettingsSection.Account -> AccountDetail(server, titles, onSignOut, firstSwitch, detail)
}
}
@@ -86,7 +86,7 @@ internal fun WhatsOnScreen(session: EmbySampleSession, plans: Map<Int, ChannelPl
var now by remember { mutableLongStateOf(System.currentTimeMillis()) }
LaunchedEffect(Unit) { while (true) { delay(1000); if (!FullScreen.active) now = System.currentTimeMillis() } }
val minute = now / 60_000
val page = remember(plans, driveIn, minute) { whatsOnPage(plans, driveIn, now) }
val page = remember(plans, driveIn, minute, AfterDarkLock.locked) { whatsOnPage(plans, driveIn, now) }
var open by remember { mutableStateOf<WhatsOnItem?>(null) }
val first = remember { FocusRequester() }
val nav = LocalNavFocus.current
@@ -68,7 +68,7 @@ internal fun whatsOnPage(plans: Map<Int, ChannelPlan>, driveIn: ChannelPlan?, no
val horizon = edition.plusDays(1 + COMING_UP_DAYS).atTime(6, 0).atZone(zone).toInstant().toEpochMilli()
val candidates = plans.flatMap { (channel, plan) ->
plan.entries.mapNotNull { entry -> whatsOnRule(channel, entry, zone)?.let { (tag, reason, score) -> WhatsOnItem(channel, entry, tag, reason, score) } }
} + driveIn?.let { plan -> driveInBills(plan, zone).map(::driveInItem) }.orEmpty()
} + driveIn?.let { plan -> driveInBills(plan, zone).filterNot { lockedOut(it) }.map(::driveInItem) }.orEmpty()
val live = candidates.filter { it.endMs > nowMs }
// A programme booked across several channels' events (a premiere's second episode) is shown once, at its first.
val firstOfRuns = live.sortedBy { it.startMs }.distinctBy { Triple(it.channel, it.tag, whatsOnEdition(it.startMs, zone)) }
@@ -0,0 +1,26 @@
package tv.orbit.classic
import org.junit.Assert.*
import org.junit.Test
class AfterDarkLockTest {
@Test fun thePinIsKeptOnlyAsASaltedHash() {
val a = pinHash("salt-one", "1234")
assertEquals(a, pinHash("salt-one", "1234"))
assertNotEquals(a, pinHash("salt-two", "1234"))
assertNotEquals(a, pinHash("salt-one", "1235"))
assertFalse("1234" in a)
assertEquals(64, a.length)
}
@Test fun lockedHidesAfterDarkAndTheLateShowOnly() {
assertTrue(lockedOut(AFTER_DARK_NUMBER, locked = true))
assertFalse(lockedOut(AFTER_DARK_NUMBER, locked = false))
assertFalse(lockedOut(101, locked = true)); assertFalse(lockedOut(TOTS_NUMBER, locked = true))
val media = ScheduledMedia(SampleItem("A film", "Movie", 90, "", "f1", 90 * 60_000L), "s1", 90 * 60_000L)
val entry = ScheduleEntry("f1", EpisodeMark(1, 1), media, 0L)
assertTrue(lockedOut(DriveInBill(DriveInKind.LateShow, listOf(entry)), locked = true))
assertFalse(lockedOut(DriveInBill(DriveInKind.Marquee, listOf(entry)), locked = true))
assertFalse(lockedOut(DriveInBill(DriveInKind.LateShow, listOf(entry)), locked = false))
}
}