From b3fb2f518fec5d444972546ee174d35a4b1cdbd0 Mon Sep 17 00:00:00 2001 From: Pauljd Date: Sat, 7 Nov 2026 22:41:02 +0000 Subject: [PATCH] Rooms sync: paired rooms keep each other's family up to date MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Pairing now leaves both TVs a lasting key. While Orbit is open on both, every two minutes they exchange profiles (with change times and removals), the PIN's salted hash, Continue watching and Taste over the home Wi-Fi, sealed with the pair's key, dated and single-use, and merged: newest change per person, removals that stick, events by id. Channels, schedules and each room's unlock stay its own. Settings › Rooms shows each paired room's last sync with a switch. 0.108.102. Co-Authored-By: Claude Opus 5.5 --- android/app/build.gradle.kts | 4 +- .../java/tv/orbit/classic/AfterDarkLock.kt | 15 +- .../main/java/tv/orbit/classic/EmbyClient.kt | 4 +- .../tv/orbit/classic/EmbyConnectionScreen.kt | 11 ++ .../java/tv/orbit/classic/MainActivity.kt | 1 + .../main/java/tv/orbit/classic/PhoneLink.kt | 10 +- .../main/java/tv/orbit/classic/Profiles.kt | 27 +++- .../main/java/tv/orbit/classic/RoomSync.kt | 136 ++++++++++++++++++ .../src/main/java/tv/orbit/classic/Rooms.kt | 7 +- .../tv/orbit/classic/SecureMediaDataSource.kt | 2 +- .../main/java/tv/orbit/classic/Settings.kt | 7 + .../java/tv/orbit/classic/RoomSyncTest.kt | 53 +++++++ 12 files changed, 261 insertions(+), 16 deletions(-) create mode 100644 android/app/src/main/java/tv/orbit/classic/RoomSync.kt create mode 100644 android/app/src/test/java/tv/orbit/classic/RoomSyncTest.kt diff --git a/android/app/build.gradle.kts b/android/app/build.gradle.kts index 9f022e42..daf8dfe0 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 = 261 - versionName = "0.108.101-tots-jingle" + versionCode = 262 + versionName = "0.108.102-rooms-sync" } 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/AfterDarkLock.kt b/android/app/src/main/java/tv/orbit/classic/AfterDarkLock.kt index 03cc6f8e..de4e6ca6 100644 --- a/android/app/src/main/java/tv/orbit/classic/AfterDarkLock.kt +++ b/android/app/src/main/java/tv/orbit/classic/AfterDarkLock.kt @@ -1,6 +1,7 @@ package tv.orbit.classic import android.content.Context +import org.json.JSONObject import android.view.KeyEvent import androidx.activity.compose.BackHandler import androidx.compose.foundation.background @@ -66,10 +67,20 @@ internal object AfterDarkLock { } 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() + prefs(context).edit().putString("after_dark_salt", salt).putString("after_dark_pin", pinHash(salt, pin)).putLong("pin_changed_at", System.currentTimeMillis()).apply() pinSet = true; lock() } - fun clear(context: Context) { prefs(context).edit().clear().apply(); pinSet = false; unlockedState = false; unlockedAt = 0L; nightly = false } + fun clear(context: Context) { prefs(context).edit().clear().putLong("pin_changed_at", System.currentTimeMillis()).apply(); pinSet = false; unlockedState = false; unlockedAt = 0L; nightly = false } + /** The PIN as rooms share it: only its salted hash and when it changed (Rooms sync). */ + fun shared(context: Context): JSONObject = prefs(context).let { p -> JSONObject().put("salt", p.getString("after_dark_salt", null) ?: JSONObject.NULL) + .put("pin", p.getString("after_dark_pin", null) ?: JSONObject.NULL).put("changedAt", p.getLong("pin_changed_at", 0)) } + /** A paired room's PIN, taken when it changed more recently than this room's. Each room keeps its own unlock. */ + fun takeShared(context: Context, o: JSONObject) { + val p = prefs(context); if (o.optLong("changedAt") <= p.getLong("pin_changed_at", 0)) return + val e = p.edit().putLong("pin_changed_at", o.optLong("changedAt")) + if (o.isNull("pin")) e.remove("after_dark_salt").remove("after_dark_pin") else e.putString("after_dark_salt", o.getString("salt")).putString("after_dark_pin", o.getString("pin")) + e.apply(); pinSet = !o.isNull("pin"); if (!pinSet) unlockedState = false + } fun unlock(context: Context, pin: String) = check(context, pin).also { if (it) { unlockedState = true; unlockedAt = System.currentTimeMillis(); prefs(context).edit().putLong("unlocked_at", unlockedAt).apply() } } fun lock() { unlockedState = false; unlockedAt = 0L; store?.edit()?.remove("unlocked_at")?.apply() } 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 01521046..d38cd2d4 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.101\"") + + ServerKind.Emby -> mapOf("X-Emby-Authorization" to "Emby Client=\"Orbit TV\", Device=\"Orbit TV\", DeviceId=\"$deviceId\", Version=\"0.108.102\"") + (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.101\"" + + ServerKind.Jellyfin -> mapOf("Authorization" to "MediaBrowser Client=\"Orbit TV\", Device=\"Orbit TV\", DeviceId=\"$deviceId\", Version=\"0.108.102\"" + (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 60d2e1bf..6762a46f 100644 --- a/android/app/src/main/java/tv/orbit/classic/EmbyConnectionScreen.kt +++ b/android/app/src/main/java/tv/orbit/classic/EmbyConnectionScreen.kt @@ -384,6 +384,17 @@ internal fun EmbyConnectionScreen(modifier: Modifier = Modifier, visible: Boolea runCatching { withContext(Dispatchers.IO) { Taste.watching(channel.number, show, channel.seriesIdAt(show.startMs), at - show.startMs, now) } } } } + // Rooms sync (7 November 2026): every two minutes while Orbit is open, with each paired room it can reach on the Wi-Fi. + LaunchedEffect(workspace) { + val finder = RoomFinder(appContext); finder.start() + try { + while (true) { + delay(120_000) + if (RoomLinks.links.none { it.on }) continue + withContext(Dispatchers.IO) { runCatching { RoomSync.round(appContext, workspace.scheduleDir, finder.found.map { it.second }) } } + } + } finally { finder.stop() } + } // 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. diff --git a/android/app/src/main/java/tv/orbit/classic/MainActivity.kt b/android/app/src/main/java/tv/orbit/classic/MainActivity.kt index b1d7c398..2675fa6d 100644 --- a/android/app/src/main/java/tv/orbit/classic/MainActivity.kt +++ b/android/app/src/main/java/tv/orbit/classic/MainActivity.kt @@ -77,6 +77,7 @@ class MainActivity : ComponentActivity() { // The phone page's server runs only while Orbit is open (Create your own from a phone). PhoneLink.init(this) Profiles.load(this) + RoomLinks.load(this) // The chosen look, before the first frame, so a light look never flashes navy. OrbitTheme.load(this) window.setBackgroundDrawable(android.graphics.drawable.ColorDrawable(Navy.toArgb())) diff --git a/android/app/src/main/java/tv/orbit/classic/PhoneLink.kt b/android/app/src/main/java/tv/orbit/classic/PhoneLink.kt index 741593c0..3ab113f6 100644 --- a/android/app/src/main/java/tv/orbit/classic/PhoneLink.kt +++ b/android/app/src/main/java/tv/orbit/classic/PhoneLink.kt @@ -158,7 +158,9 @@ internal object PhoneLink { val parts = lines.first().split(' ') if (parts.size < 2) return null val headers = lines.drop(1).filter { ':' in it }.associate { it.substringBefore(':').trim().lowercase() to it.substringAfter(':').trim() } - val length = headers["content-length"]?.toIntOrNull()?.coerceIn(0, 65_536) ?: 0 + // Rooms sync carries a family's changes, so it may be larger; everything else stays small. + val cap = if (parts[1].substringBefore('?') == "/room/sync") 2_000_000 else 65_536 + val length = headers["content-length"]?.toIntOrNull()?.coerceIn(0, cap) ?: 0 val body = ByteArray(length).also { var read = 0; while (read < length) { val n = input.read(it, read, length - read); if (n < 0) break; read += n } }.toString(Charsets.UTF_8) val path = parts[1].substringBefore('?') val query = parts[1].substringAfter('?', "").split('&').filter { '=' in it }.associate { URLDecoder.decode(it.substringBefore('='), "UTF-8") to URLDecoder.decode(it.substringAfter('='), "UTF-8") } @@ -219,6 +221,12 @@ internal object PhoneLink { offerRoom(offer) return json(out, 200, JSONObject().put("room", Rooms.name)) } + // Rooms sync between paired TVs: answered whenever Orbit is open, sealed with the pair's key, refused for anyone else. + if (r.path == "/room/sync" && r.method == "POST") { + val ctx = appContext ?: return json(out, 409, JSONObject()) + val (status, reply) = runCatching { RoomSync.answer(ctx, Workspaces.current(ctx).scheduleDir, r.body, socket.inetAddress.hostAddress) }.getOrElse { 400 to JSONObject() } + return json(out, status, reply) + } if (r.path.startsWith("/room/")) { val offer = roomOffer ?: return json(out, 404, JSONObject().put("error", "That TV isn't adding a room right now.")) val (status, reply) = runCatching { offer.handle(r.method, r.path, r.body) }.getOrElse { 400 to JSONObject() } diff --git a/android/app/src/main/java/tv/orbit/classic/Profiles.kt b/android/app/src/main/java/tv/orbit/classic/Profiles.kt index cbff2c1b..556a130e 100644 --- a/android/app/src/main/java/tv/orbit/classic/Profiles.kt +++ b/android/app/src/main/java/tv/orbit/classic/Profiles.kt @@ -43,7 +43,9 @@ internal enum class ProfileKind { Grown, Kids } internal data class Profile(val id: String, val name: String, val picture: String, val kind: ProfileKind, /** Kids only: the channels it sees. */ - val channels: Set = emptySet(), val arcade: Boolean = true, val driveIn: Boolean = false) + val channels: Set = emptySet(), val arcade: Boolean = true, val driveIn: Boolean = false, + /** When it last changed, so paired rooms keep the newest (Rooms sync, 7 November 2026). 0 for a profile never changed. */ + val updatedMs: Long = 0) /** Kids' channels to start with, from the approved design: Tots, Junior, Wonder, PixelZ, ToonZ, Heroes, Rewind, Vortex, Terra, Wild. */ internal val KidsStartChannels = setOf(TOTS_NUMBER, 611, 612, 613, 605, 602, 604, VORTEX_NUMBER, 201, 203) @@ -92,7 +94,7 @@ internal object Profiles { /** Someone new (Family v2): a stable id of their own, so their Continue watching and Taste stay theirs. */ fun add(context: Context, name: String, kind: ProfileKind, picture: String): Profile { - val p = newProfile(name, kind, picture, all.map { it.id }.toSet()) + val p = newProfile(name, kind, picture, all.map { it.id }.toSet()).copy(updatedMs = System.currentTimeMillis()) all = all + p; prefs(context).edit().putString("profiles", encode(all)).apply() return p } @@ -100,26 +102,39 @@ internal object Profiles { fun remove(context: Context, id: String): Boolean { val next = profilesWithout(all, id) ?: return false all = next; if (current?.id == id) current = null - prefs(context).edit().putString("profiles", encode(all)).apply() + // Remembered as removed, so a paired room's copy doesn't bring them back. + tombstones = tombstones + (id to System.currentTimeMillis()) + prefs(context).edit().putString("profiles", encode(all)).putString("tombstones", JSONObject(tombstones).toString()).apply() return true } + /** Profiles removed, by id, with when: kept so Rooms sync can pass the removal on. */ + var tombstones: Map = emptyMap() + private set + /** Everyone and every removal as a paired room sent them, merged and saved (Rooms sync). */ + fun replaceFromSync(context: Context, profiles: List, tombs: Map) { + all = profiles; tombstones = tombs + if (current != null && profiles.none { it.id == current?.id }) current = null else current?.let { c -> chosen = profiles.first { it.id == c.id } } + prefs(context).edit().putString("profiles", encode(all)).putString("tombstones", JSONObject(tombs).toString()).apply() + } private fun prefs(context: Context) = context.getSharedPreferences("orbit_profiles", Context.MODE_PRIVATE) fun load(context: Context) { all = runCatching { decode(prefs(context).getString("profiles", null)!!) }.getOrDefault(DefaultProfiles) kidsOn = prefs(context).getBoolean("kids_on", true) store = prefs(context) + tombstones = runCatching { JSONObject(prefs(context).getString("tombstones", "{}")!!).let { o -> o.keys().asSequence().associateWith { o.getLong(it) } } }.getOrDefault(emptyMap()) chosen = prefs(context).getString("current", null)?.let { id -> all.firstOrNull { it.id == id } } ?.takeIf { it.kind == ProfileKind.Kids || !AfterDarkLock.pinSet || AfterDarkLock.unlocked } } - fun update(context: Context, changed: Profile) { + fun update(context: Context, edited: Profile) { + val changed = edited.copy(updatedMs = System.currentTimeMillis()) all = all.map { if (it.id == changed.id) changed else it } if (current?.id == changed.id) current = changed prefs(context).edit().putString("profiles", encode(all)).apply() } fun encode(list: List) = JSONArray(list.map { p -> JSONObject().put("id", p.id).put("name", p.name).put("picture", p.picture).put("kind", p.kind.name) - .put("channels", JSONArray(p.channels.sorted())).put("arcade", p.arcade).put("driveIn", p.driveIn) + .put("channels", JSONArray(p.channels.sorted())).put("arcade", p.arcade).put("driveIn", p.driveIn).put("u", p.updatedMs) }).toString() fun decode(text: String): List { val a = JSONArray(text) @@ -127,7 +142,7 @@ internal object Profiles { val o = a.getJSONObject(i); val ch = o.optJSONArray("channels") // "Grown-ups" became "Adult" (Paul, 6 November 2026): a profile saved under the old name takes the new one. Profile(o.getString("id"), o.getString("name").let { if (it == "Grown-ups") "Adult" else it }, o.getString("picture"), ProfileKind.valueOf(o.getString("kind")), - ch?.let { c -> (0 until c.length()).map { c.getInt(it) }.toSet() }.orEmpty(), o.optBoolean("arcade", true), o.optBoolean("driveIn", false)) + ch?.let { c -> (0 until c.length()).map { c.getInt(it) }.toSet() }.orEmpty(), o.optBoolean("arcade", true), o.optBoolean("driveIn", false), o.optLong("u")) }.takeIf { list -> list.any { it.kind == ProfileKind.Grown } } ?: DefaultProfiles } } diff --git a/android/app/src/main/java/tv/orbit/classic/RoomSync.kt b/android/app/src/main/java/tv/orbit/classic/RoomSync.kt new file mode 100644 index 00000000..2b5d9a67 --- /dev/null +++ b/android/app/src/main/java/tv/orbit/classic/RoomSync.kt @@ -0,0 +1,136 @@ +package tv.orbit.classic + +import android.content.Context +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 +import java.util.Base64 + +/** + * Rooms sync (Paul, 7 November 2026): rooms that have paired keep each other's family up to date on their own. Pairing (Add a + * room, Bring in from another room) leaves both TVs with a shared key; after that, while Orbit is open on both, they exchange + * what's changed every couple of minutes over the home Wi-Fi only: profiles (and removals), the PIN's salted hash, Continue + * watching and Taste. Everything is sealed with the pair's key (AES-GCM), dated, and merged, never overwritten: the same person + * by id with the newest change winning, Taste events by id, the latest place in a programme. Channels and schedules stay each + * room's own, and each room keeps its own unlock. + */ +internal class RoomLink(val id: String, val room: String, val key: ByteArray, val on: Boolean = true, val lastSyncMs: Long = 0, val address: String? = null) { + fun toJson(): JSONObject = JSONObject().put("id", id).put("room", room).put("key", Base64.getEncoder().encodeToString(key)).put("on", on) + .put("last", lastSyncMs).put("address", address ?: JSONObject.NULL) + companion object { + fun of(o: JSONObject) = RoomLink(o.getString("id"), o.optString("room").take(30), Base64.getDecoder().decode(o.getString("key")), o.optBoolean("on", true), + o.optLong("last"), o.optString("address").takeIf { !o.isNull("address") && it.isNotBlank() }) + /** The lasting key and its id, worked out the same way on both TVs from the pairing's sealing key. */ + fun fromPairing(seal: ByteArray, room: String): RoomLink { + val key = RoomCrypto.hmac(seal, "orbit-room-link\u0001".toByteArray()) + val id = RoomCrypto.hmac(key, "orbit-room-link-id\u0001".toByteArray()).take(8).joinToString("") { "%02x".format(it) } + return RoomLink(id, room.take(30).ifBlank { "Another room" }, key) + } + } +} + +internal object RoomLinks { + var links by mutableStateOf>(emptyList()) + private set + private var prefs: android.content.SharedPreferences? = null + fun load(context: Context) { + prefs = context.applicationContext.getSharedPreferences("orbit_room_links", Context.MODE_PRIVATE) + links = runCatching { JSONArray(prefs!!.getString("links", "[]")).let { a -> (0 until a.length()).map { RoomLink.of(a.getJSONObject(it)) } } }.getOrDefault(emptyList()) + } + @Synchronized private fun save(next: List) { links = next; prefs?.edit()?.putString("links", JSONArray(next.map { it.toJson() }).toString())?.apply() } + /** A pairing finished: keep its lasting key (the same pair pairing again replaces it). */ + fun paired(seal: ByteArray, room: String) { val l = RoomLink.fromPairing(seal, room); save(links.filter { it.id != l.id && it.room != l.room } + l) } + fun setOn(id: String, on: Boolean) = save(links.map { if (it.id == id) RoomLink(it.id, it.room, it.key, on, it.lastSyncMs, it.address) else it }) + fun synced(id: String, atMs: Long, address: String?) = save(links.map { if (it.id == id) RoomLink(it.id, it.room, it.key, it.on, atMs, address ?: it.address) else it }) + fun of(id: String) = links.firstOrNull { it.id == id } +} + +/** How far apart two TVs' clocks and a message's travel may be; older messages are refused, so one can't be replayed later. */ +internal const val ROOM_SYNC_WINDOW_MS = 10 * 60_000L +/** Taste and Continue watching changes are sent from a little before the last sync, so nothing falls in a gap. */ +private const val ROOM_SYNC_OVERLAP_MS = 60 * 60_000L + +/** Profiles from two rooms: per person the newest change, minus anyone removed after their last change. */ +internal fun mergeProfilesSync(here: List, hereTombs: Map, there: List, thereTombs: Map): Pair, Map> { + val tombs = (hereTombs.keys + thereTombs.keys).associateWith { maxOf(hereTombs[it] ?: 0, thereTombs[it] ?: 0) } + val byId = LinkedHashMap() + for (p in here + there) { val have = byId[p.id]; if (have == null || p.updatedMs > have.updatedMs) byId[p.id] = p } + val kept = byId.values.filter { p -> (tombs[p.id] ?: -1) < p.updatedMs || (tombs[p.id] == null) }.take(MAX_PROFILES) + // Someone must stay able to change things: if the merge would leave no grown-up, keep this room's list as it is. + return if (kept.any { it.kind == ProfileKind.Grown }) kept to tombs else here to hereTombs +} + +internal object RoomSync { + private val seen = ArrayDeque() + + /** What this room sends: the family as it is, and Continue watching and Taste changed since [sinceMs]. */ + fun state(context: Context, scheduleDir: File, sinceMs: Long, nowMs: Long): JSONObject { + val files = JSONObject() + scheduleDir.listFiles { f -> Regex("continue-[A-Za-z0-9]{1,40}\\.json").matches(f.name) }?.forEach { files.put(it.name, it.readText()) } + File(scheduleDir, "taste").listFiles()?.forEach { f -> + when { + f.name.endsWith(".events.jsonl") -> f.readLines().filter { l -> TasteEvent.of(l)?.let { it.atMs >= sinceMs - ROOM_SYNC_OVERLAP_MS } == true } + .takeIf { it.isNotEmpty() }?.let { files.put("taste/${f.name}", it.joinToString("\n") + "\n") } + f.name.endsWith(".state.json") -> files.put("taste/${f.name}", f.readText()) + } + } + return JSONObject().put("v", 1).put("room", Rooms.name).put("at", nowMs).put("nonce", java.util.UUID.randomUUID().toString()).put("since", sinceMs) + .put("profiles", Profiles.encode(Profiles.all)).put("tombs", JSONObject(Profiles.tombstones)).put("lock", AfterDarkLock.shared(context)).put("files", files) + } + + /** Opens and checks a sealed message: the pair's key, a fresh time, a nonce not seen before. Null when it fails any of them. */ + @Synchronized fun open(link: RoomLink, sealed: String, nowMs: Long): JSONObject? { + val o = runCatching { JSONObject(String(RoomCrypto.open(link.key, sealed))) }.getOrNull() ?: return null + if (o.optInt("v") != 1 || kotlin.math.abs(nowMs - o.optLong("at")) > ROOM_SYNC_WINDOW_MS) return null + val nonce = o.optString("nonce"); if (nonce.isBlank() || nonce in seen) return null + seen.addLast(nonce); while (seen.size > 200) seen.removeFirst() + return o + } + + /** Takes in what a paired room sent: profiles and removals, the PIN, Continue watching and Taste, each merged. */ + fun merge(context: Context, scheduleDir: File, o: JSONObject, nowMs: Long) { + val there = runCatching { Profiles.decode(o.getString("profiles")) }.getOrNull() + val thereTombs = o.optJSONObject("tombs")?.let { t -> t.keys().asSequence().associateWith { t.getLong(it) } }.orEmpty() + if (there != null) { + val (merged, tombs) = mergeProfilesSync(Profiles.all, Profiles.tombstones, there, thereTombs) + if (merged != Profiles.all || tombs != Profiles.tombstones) Profiles.replaceFromSync(context, merged, tombs) + tombs.keys.filter { id -> merged.none { it.id == id } }.forEach { runCatching { forgetProfileData(scheduleDir, it) } } + } + o.optJSONObject("lock")?.let { AfterDarkLock.takeShared(context, it) } + o.optJSONObject("files")?.let { files -> runCatching { mergeFamilyFiles(scheduleDir, files, nowMs) } } + ContinueWatching.load(scheduleDir, Profiles.current?.id) + } + + /** The answering TV's side of /room/sync: returns the status and reply. */ + fun answer(context: Context, scheduleDir: File, body: String, from: String?, nowMs: Long = System.currentTimeMillis()): Pair { + val req = runCatching { JSONObject(body) }.getOrNull() ?: return 400 to JSONObject() + val link = RoomLinks.of(req.optString("link"))?.takeIf { it.on } ?: return 404 to JSONObject() + val o = open(link, req.optString("sealed"), nowMs) ?: return 403 to JSONObject() + merge(context, scheduleDir, o, nowMs) + val reply = state(context, scheduleDir, o.optLong("since"), nowMs) + RoomLinks.synced(link.id, nowMs, from) + android.util.Log.i("OrbitRooms", "sync answered link=${link.id.take(4)}") + return 200 to JSONObject().put("sealed", RoomCrypto.seal(link.key, reply.toString().toByteArray())) + } + + /** One round from this TV: each paired room it can reach, at its last address or as found on the Wi-Fi. */ + fun round(context: Context, scheduleDir: File, found: List, nowMs: Long = System.currentTimeMillis()) { + for (link in RoomLinks.links.filter { it.on }) { + for (address in (listOfNotNull(link.address) + found).distinct()) { + val call = roomTransport(address) ?: continue + val sent = state(context, scheduleDir, link.lastSyncMs, nowMs) + val (status, text) = runCatching { call("POST", "/room/sync", JSONObject().put("link", link.id).put("sealed", RoomCrypto.seal(link.key, sent.toString().toByteArray())).toString()) } + .getOrNull() ?: continue + if (status != 200) continue + val o = runCatching { open(link, JSONObject(text).getString("sealed"), System.currentTimeMillis()) }.getOrNull() ?: continue + merge(context, scheduleDir, o, System.currentTimeMillis()) + RoomLinks.synced(link.id, nowMs, address) + android.util.Log.i("OrbitRooms", "sync done link=${link.id.take(4)}") + break + } + } + } +} diff --git a/android/app/src/main/java/tv/orbit/classic/Rooms.kt b/android/app/src/main/java/tv/orbit/classic/Rooms.kt index 1042d59a..92be0d3d 100644 --- a/android/app/src/main/java/tv/orbit/classic/Rooms.kt +++ b/android/app/src/main/java/tv/orbit/classic/Rooms.kt @@ -39,7 +39,7 @@ internal object RoomCrypto { fun shared(mine: KeyPair, theirs: String): ByteArray = KeyAgreement.getInstance("ECDH").run { init(mine.private); doPhase(KeyFactory.getInstance("EC").generatePublic(X509EncodedKeySpec(Base64.getDecoder().decode(theirs))), true); generateSecret() } - private fun hmac(key: ByteArray, data: ByteArray): ByteArray = Mac.getInstance("HmacSHA256").run { init(SecretKeySpec(key, "HmacSHA256")); doFinal(data) } + internal fun hmac(key: ByteArray, data: ByteArray): ByteArray = Mac.getInstance("HmacSHA256").run { init(SecretKeySpec(key, "HmacSHA256")); doFinal(data) } /** Two keys from the agreed secret and the code: one to prove the code, one to seal what's copied. */ fun keys(secret: ByteArray, code: String, transcript: String): Pair { val prk = hmac(MessageDigest.getInstance("SHA-256").digest(transcript.toByteArray()), secret + code.toByteArray()) @@ -272,6 +272,8 @@ internal class RoomOffer(val code: String, val untilMs: Long, private val room: val text = bundle().toString() if (!RoomBundle.limit(text)) return 413 to JSONObject() state = State.Sent + // Paired from here on: both TVs keep a lasting key for Rooms sync. + runCatching { RoomLinks.paired(seal!!, joining ?: "A new TV") } android.util.Log.i("OrbitRooms", "copy sent bytes=${text.length}") 200 to JSONObject().put("sealed", RoomCrypto.seal(seal!!, text.toByteArray())) } @@ -320,7 +322,8 @@ internal class RoomJoin(private val call: (method: String, path: String, body: S val (status, text) = call("GET", "/room/copy", "") when (status) { 202 -> null - 200 -> JSONObject(String(RoomCrypto.open(seal!!, JSONObject(text).getString("sealed")))).also { check(it.getInt("version") == 1) } + 200 -> JSONObject(String(RoomCrypto.open(seal!!, JSONObject(text).getString("sealed")))).also { check(it.getInt("version") == 1) + runCatching { RoomLinks.paired(seal!!, otherRoom ?: "Another room") } } else -> error(JSONObject(text).optString("error").ifBlank { "The copy didn't arrive." }) } } 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 484b29e4..ffd912be 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.101") + next.setRequestProperty("User-Agent", "OrbitTV/0.108.102") 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/main/java/tv/orbit/classic/Settings.kt b/android/app/src/main/java/tv/orbit/classic/Settings.kt index fca366ae..8822f620 100644 --- a/android/app/src/main/java/tv/orbit/classic/Settings.kt +++ b/android/app/src/main/java/tv/orbit/classic/Settings.kt @@ -406,6 +406,13 @@ private fun RoomsDetail(firstSwitch: FocusRequester, modifier: Modifier) { SettingLine("Add a room", "Set up Orbit on another TV in your home by copying this one: channels, profiles, look and more. Your password never travels.") { OrbitButton("Add a room", onClick = { adding = true }) } + // Rooms sync (7 November 2026): each paired room, when it last synced, and a switch to stop. + RoomLinks.links.forEach { link -> + val ago = if (link.lastSyncMs == 0L) "Not synced yet: open Orbit on both TVs" else "Synced ${((System.currentTimeMillis() - link.lastSyncMs) / 60_000).coerceAtLeast(0)} min ago" + SettingLine("Sync with ${link.room}", "$ago. Profiles, the PIN, Continue watching and what Orbit has learnt. Channels and schedules stay each room's own.") { + OnOff(link.on, Modifier, onClick = { RoomLinks.setOn(link.id, !link.on) }) + } + } Rooms.joined.forEach { (room, at) -> val day = java.time.Instant.ofEpochMilli(at).atZone(java.time.ZoneId.systemDefault()).toLocalDate() SettingLine(room, "Copied this Orbit's set-up on ${day.dayOfMonth} ${day.month.getDisplayName(java.time.format.TextStyle.SHORT, java.util.Locale.UK)}. Not connected: it plans its own schedules.") {} diff --git a/android/app/src/test/java/tv/orbit/classic/RoomSyncTest.kt b/android/app/src/test/java/tv/orbit/classic/RoomSyncTest.kt new file mode 100644 index 00000000..002f8d71 --- /dev/null +++ b/android/app/src/test/java/tv/orbit/classic/RoomSyncTest.kt @@ -0,0 +1,53 @@ +package tv.orbit.classic + +import org.json.JSONObject +import org.junit.Assert.* +import org.junit.Test + +/** Rooms sync (7 November 2026): newest change per person, removals stick, and only the paired room's fresh messages count. */ +class RoomSyncTest { + private val paul = Profile("grown", "Paul", "sil-blue", ProfileKind.Grown, updatedMs = 100) + private val kids = Profile("kids", "Amelia", "ollie", ProfileKind.Kids, DefaultProfiles[1].channels, updatedMs = 100) + + @Test fun aNewProfileArrivesAndTheNewestChangeWins() { + val cheryl = Profile("pcher01", "Cheryl", "sil-pink", ProfileKind.Grown, updatedMs = 300) + val renamedHere = paul.copy(name = "Paul D", updatedMs = 500) + val (merged, _) = mergeProfilesSync(listOf(renamedHere, kids), emptyMap(), listOf(paul, kids, cheryl), emptyMap()) + assertEquals(listOf("grown", "kids", "pcher01"), merged.map { it.id }) + assertEquals("Paul D", merged.first().name) + val (back, _) = mergeProfilesSync(listOf(paul, kids, cheryl), emptyMap(), listOf(renamedHere, kids), emptyMap()) + assertEquals("Paul D", back.first { it.id == "grown" }.name) + assertEquals(3, back.size) + } + + @Test fun aRemovalSticksUnlessTheProfileChangedAfterIt() { + val cheryl = Profile("pcher01", "Cheryl", "sil-pink", ProfileKind.Grown, updatedMs = 300) + val (gone, tombs) = mergeProfilesSync(listOf(paul, kids, cheryl), emptyMap(), listOf(paul, kids), mapOf("pcher01" to 400L)) + assertEquals(listOf("grown", "kids"), gone.map { it.id }); assertEquals(400L, tombs["pcher01"]) + // Edited in the other room after the removal: the newer edit keeps them. + val (kept, _) = mergeProfilesSync(listOf(paul, kids), mapOf("pcher01" to 400L), listOf(cheryl.copy(updatedMs = 500)), emptyMap()) + assertTrue(kept.any { it.id == "pcher01" }) + // A merge never leaves the house without a grown-up. + val (safe, _) = mergeProfilesSync(listOf(paul, kids), emptyMap(), emptyList(), mapOf("grown" to 900L)) + assertTrue(safe.any { it.kind == ProfileKind.Grown }) + } + + @Test fun bothTvsWorkOutTheSameLinkAndOnlyItOpensMessages() { + val seal = ByteArray(32) { it.toByte() } + val a = RoomLink.fromPairing(seal, "Living Room"); val b = RoomLink.fromPairing(seal, "Upstairs") + assertEquals(a.id, b.id); assertArrayEquals(a.key, b.key) + val stranger = RoomLink.fromPairing(ByteArray(32) { 7 }, "Next door") + val now = 1_794_000_000_000L + fun msg(at: Long, nonce: String) = RoomCrypto.seal(a.key, JSONObject().put("v", 1).put("at", at).put("nonce", nonce).toString().toByteArray()) + assertNotNull(RoomSync.open(b, msg(now, "n1"), now)) + assertNull("the same message twice is refused", RoomSync.open(b, msg(now, "n1"), now)) + assertNull("too old", RoomSync.open(b, msg(now - ROOM_SYNC_WINDOW_MS - 1, "n2"), now)) + assertNull("another pair's key", RoomSync.open(stranger, msg(now, "n3"), now)) + assertNull("tampered", RoomSync.open(b, msg(now, "n4").dropLast(4) + "AAAA", now)) + } + + @Test fun profilesKeepTheirChangeTimeWhenSaved() { + val back = Profiles.decode(Profiles.encode(listOf(paul.copy(updatedMs = 1234), kids))) + assertEquals(1234L, back.first().updatedMs) + } +}