From 11af81c859528ce020e32eeb4642faad962e94d2 Mon Sep 17 00:00:00 2001 From: Pauljd Date: Tue, 10 Nov 2026 09:49:38 +0000 Subject: [PATCH] Household and Play editions, one version-code counter (build 40: 400 household, 402 Play) Both editions are tv.orbit.classic. The Play edition has no room updater, no PackageInstaller, no REQUEST_INSTALL_PACKAGES, no adb install check and no adb test hooks; Google Play updates it. The household edition keeps all of them. Release builds and the Play bundle are unsigned until signing is approved. The release gate builds both editions and the bundle, tests both, and checks what was built: ids, codes above every earlier one (the reserved 390 included), Play isolation, household intact, nothing signed. Co-Authored-By: Claude Opus 5.5 --- android/app/build.gradle.kts | 21 +++- android/app/src/household/AndroidManifest.xml | 13 +++ .../java/tv/orbit/classic/Edition.kt | 66 +++++++++++++ .../java/tv/orbit/classic/InstallSnapshot.kt | 4 +- .../tv/orbit/classic/PlaybackTestActivity.kt | 0 .../java/tv/orbit/classic/RoomUpdates.kt | 1 - android/app/src/main/AndroidManifest.xml | 8 -- .../java/tv/orbit/classic/CatalogueShadow.kt | 2 +- .../src/main/java/tv/orbit/classic/Edition.kt | 13 +++ .../java/tv/orbit/classic/MainActivity.kt | 29 ++---- .../main/java/tv/orbit/classic/PhoneLink.kt | 15 +-- .../src/main/java/tv/orbit/classic/RoomsUi.kt | 2 +- .../src/play/java/tv/orbit/classic/Edition.kt | 24 +++++ .../tv/orbit/classic/InstallRestoreTest.kt | 0 .../java/tv/orbit/classic/PlaybackTestTest.kt | 0 .../java/tv/orbit/classic/RoomUpdatesTest.kt | 0 tools/check_editions.py | 96 +++++++++++++++++++ tools/known-version-codes.txt | 39 ++++++++ tools/verify.sh | 39 ++++---- 19 files changed, 302 insertions(+), 70 deletions(-) create mode 100644 android/app/src/household/AndroidManifest.xml create mode 100644 android/app/src/household/java/tv/orbit/classic/Edition.kt rename android/app/src/{main => household}/java/tv/orbit/classic/InstallSnapshot.kt (97%) rename android/app/src/{main => household}/java/tv/orbit/classic/PlaybackTestActivity.kt (100%) rename android/app/src/{main => household}/java/tv/orbit/classic/RoomUpdates.kt (99%) create mode 100644 android/app/src/main/java/tv/orbit/classic/Edition.kt create mode 100644 android/app/src/play/java/tv/orbit/classic/Edition.kt rename android/app/src/{test => testHousehold}/java/tv/orbit/classic/InstallRestoreTest.kt (100%) rename android/app/src/{test => testHousehold}/java/tv/orbit/classic/PlaybackTestTest.kt (100%) rename android/app/src/{test => testHousehold}/java/tv/orbit/classic/RoomUpdatesTest.kt (100%) create mode 100644 tools/check_editions.py create mode 100644 tools/known-version-codes.txt diff --git a/android/app/build.gradle.kts b/android/app/build.gradle.kts index cf19e109..5462e2c1 100644 --- a/android/app/build.gradle.kts +++ b/android/app/build.gradle.kts @@ -2,6 +2,8 @@ plugins { id("com.android.application") id("org.jetbrains.kotlin.plugin.compose") } +/** The release's build number: versionCode is this x 10 plus the edition's channel. */ +val ORBIT_BUILD = 40 android { namespace = "tv.orbit.classic" compileSdk = 36 @@ -9,16 +11,25 @@ android { applicationId = "tv.orbit.classic" minSdk = 26 targetSdk = 36 - versionCode = 323 - versionName = "0.126.0-noserver" + versionName = "0.127.0" + } + // Two editions of the same app (Paul, 10 November 2026): the household build, which updates itself between rooms, and the + // Play build, which only Google Play updates. Both are tv.orbit.classic, so a TV can move between them keeping its data. + // One version-code counter for both: build x 10 + channel (0 household, 2 Play, 9 a recovery build of that build), so the + // Play build of a release is just above the household one and the next release is above both. Build 40 is the first: + // every earlier code, the reserved 390 recovery build among them, is below it (tools/check_version_codes.py). + flavorDimensions += "edition" + productFlavors { + create("household") { dimension = "edition"; versionCode = ORBIT_BUILD * 10 + 0 } + create("play") { dimension = "edition"; versionCode = ORBIT_BUILD * 10 + 2; versionNameSuffix = "-play" } } buildFeatures { compose = true } // The finished build for the TVs (Paul, 6 November 2026: the test build stuttered on the box). Not debuggable, so - // Android compiles it fully; signed with the same key as the test builds, so it installs over them keeping everything. + // Android compiles it fully. Unsigned (Paul, 10 November 2026): nothing is signed until he approves the new signing key. buildTypes { release { isMinifyEnabled = false - signingConfig = signingConfigs.getByName("debug") + signingConfig = null } // The playback test build (Paul, 9 November 2026): a separate app, tv.orbit.classic.playtest, with its own data, so it // can never touch the household's schedules, Taste or Continue watching. Its adb-only test player lives in @@ -34,6 +45,8 @@ android { testOptions { unitTests.isReturnDefaultValues = true } compileOptions { sourceCompatibility = JavaVersion.VERSION_17; targetCompatibility = JavaVersion.VERSION_17 } } +// The playback test build is household only: there's no Play test build. +androidComponents { beforeVariants { v -> if (v.buildType == "playtest" && v.productFlavors.any { it.second == "play" }) v.enable = false } } dependencies { implementation(platform("androidx.compose:compose-bom:2025.08.01")) implementation("androidx.activity:activity-compose:1.10.1") diff --git a/android/app/src/household/AndroidManifest.xml b/android/app/src/household/AndroidManifest.xml new file mode 100644 index 00000000..ed0f48f4 --- /dev/null +++ b/android/app/src/household/AndroidManifest.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/android/app/src/household/java/tv/orbit/classic/Edition.kt b/android/app/src/household/java/tv/orbit/classic/Edition.kt new file mode 100644 index 00000000..da66a5de --- /dev/null +++ b/android/app/src/household/java/tv/orbit/classic/Edition.kt @@ -0,0 +1,66 @@ +package tv.orbit.classic + +import android.app.Activity +import android.content.Context +import android.content.Intent +import androidx.compose.runtime.Composable +import org.json.JSONObject +import java.io.OutputStream + +/** + * The household edition (Paul, 10 November 2026): Orbit as the TVs at home run it. It shares itself with other rooms and + * installs a newer copy from one (RoomUpdates: same app, newer, signed exactly as installed, and Android asks the viewer), + * and it answers the adb-only requests: the install check, the provider and player switches, the shadow comparison and the + * hand-run playback test. None of this is in the Play edition. + */ +internal object Edition { + const val NAME = "household" + + /** The adb-only requests, read at start and when adb sends them to an Orbit already open. */ + fun readAdbRequests(activity: Activity, intent: Intent?) { + if (intent?.getBooleanExtra("orbit_intro_test", false) == true) IntroTrial.nextTune = true + intent?.getStringExtra("orbit_inspect_series")?.take(120)?.let { SeriesInspection.title = it } + if (intent?.getBooleanExtra("orbit_read_evidence", false) == true) EvidenceRequest.pending = true + // Provider contract, step 3: the catalogue switch and the read-only shadow comparison. + when (intent?.getStringExtra("orbit_provider_catalogue")) { "on" -> ProviderSwitches.setCatalogue(activity, true); "off" -> ProviderSwitches.setCatalogue(activity, false) } + // Player improvements (9 November 2026): frame-rate matching and AVI, each off until switched on. + when (intent?.getStringExtra("orbit_frame_rate")) { "on" -> PlayerSwitches.setFrameRate(activity, true); "off" -> PlayerSwitches.setFrameRate(activity, false) } + intent?.getStringExtra("orbit_even_volume")?.let { PlayerSwitches.setEvenVolume(activity, it) } + when (intent?.getStringExtra("orbit_avi")) { "on" -> PlayerSwitches.setAvi(activity, true); "off" -> PlayerSwitches.setAvi(activity, false) } + if (intent?.getBooleanExtra("orbit_shadow_catalogue_stop", false) == true) CatalogueShadow.cancel = true + if (intent?.hasExtra("orbit_shadow_from") == true) CatalogueShadow.from = intent.getLongExtra("orbit_shadow_from", 0L).coerceAtLeast(0L) + if (intent?.getBooleanExtra("orbit_shadow_resume", false) == true) CatalogueShadow.resume = true + if (intent?.hasExtra("orbit_shadow_catalogue") == true) CatalogueShadow.pending = intent.getIntExtra("orbit_shadow_catalogue", 5) + } + + /** The hand-run playback test opens over Orbit, which stops in the background as it would for any other app, and comes back when it ends. */ + fun openPlaybackTest(activity: Activity, intent: Intent?) { + intent?.getStringExtra("orbit_play_test")?.takeIf(EmbyClient::validId)?.let { item -> + activity.startActivity(Intent(activity, PlaybackTestActivity::class.java).putExtra(PlaybackTestActivity.ITEM, item)) + } + } + + suspend fun lookForUpdate(context: Context) = RoomUpdates.look(context) + + fun sharedBuild(context: Context): SharedBuild? = RoomUpdates.shared(context) + + @Composable fun UpdateCard() = RoomUpdateCard() + + /** The two update routes on the room link: this Orbit's version, and its installed copy. True when [path] was one of them. */ + fun serveUpdate(path: String, method: String, out: OutputStream, shared: SharedBuild?, json: (Int, JSONObject) -> Unit): Boolean { + if (path == "/room/version" && method == "GET") { + val build = shared ?: return true.also { json(404, JSONObject()) } + json(200, JSONObject().put("code", build.code).put("name", build.name).put("room", Rooms.name)); return true + } + if (path == "/room/orbit.apk" && method == "GET") { + // The installed copy, streamed: another room checks it's newer and signed as it is before Android installs it. + val build = shared?.takeIf { it.file.isFile } ?: return true.also { json(404, JSONObject()) } + val head = listOf("HTTP/1.1 200 OK", "Content-Type: application/vnd.android.package-archive", "Content-Length: ${build.file.length()}", "Cache-Control: no-store", + "X-Content-Type-Options: nosniff", "Connection: close").joinToString("\r\n") + "\r\n\r\n" + out.write(head.toByteArray(Charsets.ISO_8859_1)); build.file.inputStream().use { it.copyTo(out, 64 * 1024) }; out.flush() + android.util.Log.i("OrbitRooms", "update shared bytes=${build.file.length()}") + return true + } + return false + } +} diff --git a/android/app/src/main/java/tv/orbit/classic/InstallSnapshot.kt b/android/app/src/household/java/tv/orbit/classic/InstallSnapshot.kt similarity index 97% rename from android/app/src/main/java/tv/orbit/classic/InstallSnapshot.kt rename to android/app/src/household/java/tv/orbit/classic/InstallSnapshot.kt index fd81b29e..cbc86550 100644 --- a/android/app/src/main/java/tv/orbit/classic/InstallSnapshot.kt +++ b/android/app/src/household/java/tv/orbit/classic/InstallSnapshot.kt @@ -28,7 +28,7 @@ class InstallSnapshotReceiver : BroadcastReceiver() { // adb can't make folders in Orbit's shared folder on Android 14, only put files in one Orbit made. File(context.getExternalFilesDir(null), "install-restore").run { deleteRecursively(); mkdirs(); "ready" } } else if (intent.getStringExtra("do") == "restore") { - if (InstallSnapshot.screenOpen) "refused: Orbit is open; force-stop it first" + if (OrbitScreen.open) "refused: Orbit is open; force-stop it first" else File(context.getExternalFilesDir(null), "install-restore").let { folder -> // The pushed copy goes once it's been used, restored or refused. try { InstallRestore.apply(context.filesDir.parentFile!!, folder, intent.getStringExtra("confirm"), System.currentTimeMillis()) } @@ -49,8 +49,6 @@ class InstallSnapshotReceiver : BroadcastReceiver() { } internal object InstallSnapshot { - /** Orbit's screen is open in this process (set by MainActivity); a restore waits until it isn't. */ - @Volatile var screenOpen = false // A plain version, or one with a short suffix (0.110.7-arcade1), so a trial build's name doesn't refuse the rollback copy. private val versionShape = Regex("""\d+\.\d+\.\d+(-[a-z0-9]+(-[a-z0-9]+)*)?""") diff --git a/android/app/src/main/java/tv/orbit/classic/PlaybackTestActivity.kt b/android/app/src/household/java/tv/orbit/classic/PlaybackTestActivity.kt similarity index 100% rename from android/app/src/main/java/tv/orbit/classic/PlaybackTestActivity.kt rename to android/app/src/household/java/tv/orbit/classic/PlaybackTestActivity.kt diff --git a/android/app/src/main/java/tv/orbit/classic/RoomUpdates.kt b/android/app/src/household/java/tv/orbit/classic/RoomUpdates.kt similarity index 99% rename from android/app/src/main/java/tv/orbit/classic/RoomUpdates.kt rename to android/app/src/household/java/tv/orbit/classic/RoomUpdates.kt index bc3c77dc..f258fed6 100644 --- a/android/app/src/main/java/tv/orbit/classic/RoomUpdates.kt +++ b/android/app/src/household/java/tv/orbit/classic/RoomUpdates.kt @@ -41,7 +41,6 @@ import java.net.URL * - Before installing, this room's schedules are copied aside (schedule-rollback-), as every install does. * - Only on the home network, through the phone link, and only while the other Orbit is open. */ -internal class SharedBuild(val code: Long, val name: String, val file: File) internal class UpdateOffer(val room: String, val address: String, val code: Long, val name: String) diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml index 490b9858..c1926292 100644 --- a/android/app/src/main/AndroidManifest.xml +++ b/android/app/src/main/AndroidManifest.xml @@ -1,7 +1,5 @@ - - @@ -10,11 +8,5 @@ - - - - - - diff --git a/android/app/src/main/java/tv/orbit/classic/CatalogueShadow.kt b/android/app/src/main/java/tv/orbit/classic/CatalogueShadow.kt index 9ff5f568..7000033f 100644 --- a/android/app/src/main/java/tv/orbit/classic/CatalogueShadow.kt +++ b/android/app/src/main/java/tv/orbit/classic/CatalogueShadow.kt @@ -95,7 +95,7 @@ internal object CatalogueShadow { shouldStop = { when { cancel -> "cancelled" - !InstallSnapshot.screenOpen -> "Orbit closed" + !OrbitScreen.open -> "Orbit closed" PlaybackHealth.stalls - stallsAtStart >= MAX_STALLS -> "playback stalled $MAX_STALLS times" runtime.totalMemory() - runtime.freeMemory() > runtime.maxMemory() * 8 / 10 -> "memory above 80%" else -> null diff --git a/android/app/src/main/java/tv/orbit/classic/Edition.kt b/android/app/src/main/java/tv/orbit/classic/Edition.kt new file mode 100644 index 00000000..933fd212 --- /dev/null +++ b/android/app/src/main/java/tv/orbit/classic/Edition.kt @@ -0,0 +1,13 @@ +package tv.orbit.classic + +import java.io.File + +/** + * What the two editions share (Paul, 10 November 2026). Each edition has its own `Edition` object in its source set: + * src/household (updates between rooms, the adb install check and test hooks) and src/play (none of those; Google Play + * updates it). Everything else, Rooms, profiles, Taste, Continue Watching, the Arcade and sync, is the same code in both. + */ +internal class SharedBuild(val code: Long, val name: String, val file: File) + +/** Orbit's screen is open in this process (set by MainActivity): a restore waits until it isn't, and the shadow comparison stops. */ +internal object OrbitScreen { @Volatile var open = false } 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 54a3027e..1c95e571 100644 --- a/android/app/src/main/java/tv/orbit/classic/MainActivity.kt +++ b/android/app/src/main/java/tv/orbit/classic/MainActivity.kt @@ -53,35 +53,21 @@ class MainActivity : ComponentActivity() { if (Onboarding.done(this)) { RoomBeacon.on(this) // Updates shared between rooms: a newer Orbit in another room is offered, with Install? and Not now. - lifecycleScope.launch { runCatching { RoomUpdates.look(this@MainActivity) } } + lifecycleScope.launch { runCatching { Edition.lookForUpdate(this@MainActivity) } } } } // Phones stay connected while Orbit is in the background (Paul, 8 November 2026: the web app couldn't connect while the TV // was in another app), and paired rooms keep syncing; the phone says Orbit isn't on screen instead of failing to load. - override fun onDestroy() { InstallSnapshot.screenOpen = false; super.onDestroy() } + override fun onDestroy() { OrbitScreen.open = false; super.onDestroy() } override fun onStop() { WatchCheck.stopped(); OrbitCompanion.onTv = false; PhoneLink.offerRoom(null); if (PhoneLink.phones.isEmpty() && RoomLinks.links.none { it.on }) { RoomBeacon.off(this); PhoneLink.stop() }; super.onStop() } /** * The adb-only requests (inspection, evidence, the provider switch and shadow comparison). Read at start and, since Orbit * opens as one copy (singleTask, 8 November 2026), also when adb sends them to an Orbit already open. */ - private fun readAdbRequests(intent: android.content.Intent?) { - if (intent?.getBooleanExtra("orbit_intro_test", false) == true) IntroTrial.nextTune = true - intent?.getStringExtra("orbit_inspect_series")?.take(120)?.let { SeriesInspection.title = it } - if (intent?.getBooleanExtra("orbit_read_evidence", false) == true) EvidenceRequest.pending = true - // Provider contract, step 3: the catalogue switch and the read-only shadow comparison. - when (intent?.getStringExtra("orbit_provider_catalogue")) { "on" -> ProviderSwitches.setCatalogue(this, true); "off" -> ProviderSwitches.setCatalogue(this, false) } - // Player improvements (9 November 2026): frame-rate matching and AVI, each off until switched on. - when (intent?.getStringExtra("orbit_frame_rate")) { "on" -> PlayerSwitches.setFrameRate(this, true); "off" -> PlayerSwitches.setFrameRate(this, false) } - intent?.getStringExtra("orbit_even_volume")?.let { PlayerSwitches.setEvenVolume(this, it) } - when (intent?.getStringExtra("orbit_avi")) { "on" -> PlayerSwitches.setAvi(this, true); "off" -> PlayerSwitches.setAvi(this, false) } - if (intent?.getBooleanExtra("orbit_shadow_catalogue_stop", false) == true) CatalogueShadow.cancel = true - if (intent?.hasExtra("orbit_shadow_from") == true) CatalogueShadow.from = intent.getLongExtra("orbit_shadow_from", 0L).coerceAtLeast(0L) - if (intent?.getBooleanExtra("orbit_shadow_resume", false) == true) CatalogueShadow.resume = true - if (intent?.hasExtra("orbit_shadow_catalogue") == true) CatalogueShadow.pending = intent.getIntExtra("orbit_shadow_catalogue", 5) - } + private fun readAdbRequests(intent: android.content.Intent?) = Edition.readAdbRequests(this, intent) override fun onNewIntent(intent: android.content.Intent) { super.onNewIntent(intent); setIntent(intent); readAdbRequests(intent) } override fun onCreate(savedInstanceState: Bundle?) { - InstallSnapshot.screenOpen = true + OrbitScreen.open = true OrbitCompanion.activity = java.lang.ref.WeakReference(this) super.onCreate(savedInstanceState) tv.orbit.classic.ArcadeProgress.init(this) @@ -92,10 +78,7 @@ class MainActivity : ComponentActivity() { ProviderSwitches.load(this) PlayerSwitches.load(this) readAdbRequests(intent) - // The hand-run playback test opens over Orbit, which stops in the background as it would for any other app, and comes back when it ends. - intent?.getStringExtra("orbit_play_test")?.takeIf(EmbyClient::validId)?.let { item -> - startActivity(android.content.Intent(this, PlaybackTestActivity::class.java).putExtra(PlaybackTestActivity.ITEM, item)) - } + Edition.openPlaybackTest(this, intent) // Before anything is drawn, so a locked After Dark never shows for a moment. AfterDarkLock.load(this) // Opening the saved sign-in takes seconds on the box: start it now, while the first screen is drawn. @@ -266,7 +249,7 @@ private fun OrbitApp() { if (SleepTimer.goodnight && !FullScreen.active) LunaGoodnight() // A new TV joining (Multiroom auto-scan), over everything else; and a newer Orbit from another room. RoomKnockOverlay() - RoomUpdateCard() + Edition.UpdateCard() // Settings › Character cameos › Show one. CameoPreviewOverlay() } 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 012efbb6..7178b634 100644 --- a/android/app/src/main/java/tv/orbit/classic/PhoneLink.kt +++ b/android/app/src/main/java/tv/orbit/classic/PhoneLink.kt @@ -213,19 +213,8 @@ internal object PhoneLink { val input = BufferedInputStream(socket.getInputStream()); val out = socket.getOutputStream() val r = readRequest(input) ?: return if (!hostIsAnAddress(r.headers["host"])) return respond(out, 400, "text/plain", "Use the TV's address.".toByteArray()) - if (r.path == "/room/version" && r.method == "GET") { - val build = shared ?: return json(out, 404, JSONObject()) - return json(out, 200, JSONObject().put("code", build.code).put("name", build.name).put("room", Rooms.name)) - } - if (r.path == "/room/orbit.apk" && r.method == "GET") { - // The installed copy, streamed: another room checks it's newer and signed as it is before Android installs it. - val build = shared?.takeIf { it.file.isFile } ?: return json(out, 404, JSONObject()) - val head = listOf("HTTP/1.1 200 OK", "Content-Type: application/vnd.android.package-archive", "Content-Length: ${build.file.length()}", "Cache-Control: no-store", - "X-Content-Type-Options: nosniff", "Connection: close").joinToString("\r\n") + "\r\n\r\n" - out.write(head.toByteArray(Charsets.ISO_8859_1)); build.file.inputStream().use { it.copyTo(out, 64 * 1024) }; out.flush() - android.util.Log.i("OrbitRooms", "update shared bytes=${build.file.length()}") - return - } + // Updates between rooms: the household edition answers these; the Play edition never shares itself. + if (Edition.serveUpdate(r.path, r.method, out, shared) { status, body -> json(out, status, body) }) return if (r.path == "/room/knock" && r.method == "POST") { // A new TV asks to join: this one shows a code, or the one it's already showing. One knock every 20 seconds. roomOffer?.takeIf { it.state == RoomOffer.State.Waiting && System.currentTimeMillis() < it.untilMs }?.let { return json(out, 200, JSONObject().put("room", Rooms.name)) } diff --git a/android/app/src/main/java/tv/orbit/classic/RoomsUi.kt b/android/app/src/main/java/tv/orbit/classic/RoomsUi.kt index c2f2c409..c5ae5bec 100644 --- a/android/app/src/main/java/tv/orbit/classic/RoomsUi.kt +++ b/android/app/src/main/java/tv/orbit/classic/RoomsUi.kt @@ -84,7 +84,7 @@ internal object RoomBeacon { if (registration != null) return val app = context.applicationContext PhoneLink.knock = { joining -> RoomOffer(RoomCrypto.code(), System.currentTimeMillis() + OFFER_MS, Rooms.name, knocked = true) { RoomBundle.collect(app, Workspaces.current(app), Rooms.name) }.also { it.joining = joining } } - PhoneLink.shared = RoomUpdates.shared(app) + PhoneLink.shared = Edition.sharedBuild(app) PhoneLink.listening = true val nsd = app.getSystemService(Context.NSD_SERVICE) as? NsdManager ?: return registration = object : NsdManager.RegistrationListener { diff --git a/android/app/src/play/java/tv/orbit/classic/Edition.kt b/android/app/src/play/java/tv/orbit/classic/Edition.kt new file mode 100644 index 00000000..21ae1fd9 --- /dev/null +++ b/android/app/src/play/java/tv/orbit/classic/Edition.kt @@ -0,0 +1,24 @@ +package tv.orbit.classic + +import android.app.Activity +import android.content.Context +import android.content.Intent +import androidx.compose.runtime.Composable +import org.json.JSONObject +import java.io.OutputStream + +/** + * The Play edition (Paul, 10 November 2026): only Google Play updates it (Play's Device and Network Abuse policy), so it + * never offers, fetches, shares or installs a copy of Orbit, and it holds no install permission. adb's test requests and the + * install check aren't in it. Rooms, profiles, Taste, Continue Watching, the Arcade and sync are the same as at home. + */ +internal object Edition { + const val NAME = "play" + fun readAdbRequests(activity: Activity, intent: Intent?) {} + fun openPlaybackTest(activity: Activity, intent: Intent?) {} + suspend fun lookForUpdate(context: Context) {} + fun sharedBuild(context: Context): SharedBuild? = null + @Composable fun UpdateCard() {} + /** Never answers the update routes: another room asking gets the usual "not found". */ + fun serveUpdate(path: String, method: String, out: OutputStream, shared: SharedBuild?, json: (Int, JSONObject) -> Unit): Boolean = false +} diff --git a/android/app/src/test/java/tv/orbit/classic/InstallRestoreTest.kt b/android/app/src/testHousehold/java/tv/orbit/classic/InstallRestoreTest.kt similarity index 100% rename from android/app/src/test/java/tv/orbit/classic/InstallRestoreTest.kt rename to android/app/src/testHousehold/java/tv/orbit/classic/InstallRestoreTest.kt diff --git a/android/app/src/test/java/tv/orbit/classic/PlaybackTestTest.kt b/android/app/src/testHousehold/java/tv/orbit/classic/PlaybackTestTest.kt similarity index 100% rename from android/app/src/test/java/tv/orbit/classic/PlaybackTestTest.kt rename to android/app/src/testHousehold/java/tv/orbit/classic/PlaybackTestTest.kt diff --git a/android/app/src/test/java/tv/orbit/classic/RoomUpdatesTest.kt b/android/app/src/testHousehold/java/tv/orbit/classic/RoomUpdatesTest.kt similarity index 100% rename from android/app/src/test/java/tv/orbit/classic/RoomUpdatesTest.kt rename to android/app/src/testHousehold/java/tv/orbit/classic/RoomUpdatesTest.kt diff --git a/tools/check_editions.py b/tools/check_editions.py new file mode 100644 index 00000000..3f555da4 --- /dev/null +++ b/tools/check_editions.py @@ -0,0 +1,96 @@ +#!/usr/bin/env python3 +""" +The editions check in the release gate (Paul, 10 November 2026). Reads what was actually built, never the source: + - the household APK, the Play APK, and the Play bundle (.aab), whose manifest is converted with aapt2 and read the same way; + - both editions are tv.orbit.classic, with versionCode = build x 10 + 0 (household) and + 2 (Play), above every code in + tools/known-version-codes.txt (and in ORBIT_APKS when that folder is there), the reserved 390 recovery build included; + - the Play APK and bundle hold no install permission, no PackageInstaller, no room-update or test hooks, no server address; + - the household APK still has its updater, install permission and install check; + - nothing is signed: no v1 signature files and no APK signing block. + check_editions.py +""" +import os, re, subprocess, sys, tempfile, zipfile + +household_apk, play_apk, play_aab, aapt2 = sys.argv[1:5] +here = os.path.dirname(os.path.abspath(__file__)) +problems = [] + +def badging(apk): + out = subprocess.run([aapt2, "dump", "badging", apk], capture_output=True, text=True, check=True).stdout + m = re.search(r"package: name='([^']*)' versionCode='(\d+)' versionName='([^']*)'", out) + return m[1], int(m[2]), m[3], sorted(set(re.findall(r"uses-permission: name='([^']*)'", out))) + +def aab_as_apk(aab, into): + """The bundle's base module, as aapt2 reads it: its proto manifest and resources converted to an ordinary APK.""" + proto = os.path.join(into, "proto.apk"); binary = os.path.join(into, "binary.apk") + with zipfile.ZipFile(aab) as z, zipfile.ZipFile(proto, "w") as out: + for n in z.namelist(): + if not n.startswith("base/"): continue + rest = n[len("base/"):] + if rest == "manifest/AndroidManifest.xml": out.writestr("AndroidManifest.xml", z.read(n)) + elif rest == "resources.pb" or rest.startswith("res/"): out.writestr(rest, z.read(n)) + subprocess.run([aapt2, "convert", "--output-format", "binary", "-o", binary, proto], check=True, capture_output=True) + return binary + +def dex(path): + with zipfile.ZipFile(path) as z: + return b"".join(z.read(n) for n in z.namelist() if re.search(r"(^|/)classes\d*\.dex$", n) or n.startswith(("assets/", "base/assets/"))) + +def signed(path): + with zipfile.ZipFile(path) as z: + if any(re.match(r"META-INF/.*\.(RSA|DSA|EC|SF)$", n) for n in z.namelist()): return True + return b"APK Sig Block 42" in open(path, "rb").read() + +known = [] +for line in open(os.path.join(here, "known-version-codes.txt")): + if line.strip() and not line.startswith("#"): + code, package, name = line.split()[:3]; known.append((int(code), package, name)) +apks = os.environ.get("ORBIT_APKS", "/home/pauljd/Documents/OrbitTV/apks") +if os.path.isdir(apks): + for root, _, files in os.walk(apks): + for f in files: + if f.endswith(".apk"): + try: p, c, n, _ = badging(os.path.join(root, f)); known.append((c, p, n)) + except Exception: pass +highest = max(c for c, p, _ in known if p.startswith("tv.orbit.classic")) + +with tempfile.TemporaryDirectory() as tmp: + editions = {"household APK": badging(household_apk), "Play APK": badging(play_apk), "Play bundle": badging(aab_as_apk(play_aab, tmp))} +for label, (package, code, name, perms) in editions.items(): + print(f"{label}: {package} versionCode {code} versionName {name}") + if package != "tv.orbit.classic": problems.append(f"{label} is {package}, not tv.orbit.classic") +hh, pa, bu = (editions[k][1] for k in ("household APK", "Play APK", "Play bundle")) +build = hh // 10 +if hh % 10 != 0: problems.append(f"household code {hh} doesn't end in 0") +if pa != build * 10 + 2 or bu != pa: problems.append(f"Play codes {pa}/{bu} aren't {build * 10 + 2}") +if hh <= highest: problems.append(f"household code {hh} isn't above the highest code built so far, {highest}") +recovery = build * 10 + 9 +if any(c == recovery for c, _, _ in known): problems.append(f"this build's recovery code {recovery} is already used") +print(f"highest earlier code {highest} (reserved recovery 390 included); this build {build}: household {hh}, Play {pa}, recovery slot {recovery}") + +for label in ("Play APK", "Play bundle"): + if "android.permission.REQUEST_INSTALL_PACKAGES" in editions[label][3]: problems.append(f"{label} asks for REQUEST_INSTALL_PACKAGES") +if "android.permission.REQUEST_INSTALL_PACKAGES" not in editions["household APK"][3]: problems.append("household APK lost REQUEST_INSTALL_PACKAGES") + +forbidden = [b"android/content/pm/PackageInstaller", b"RoomUpdates", b"ROOM_UPDATE", b"/room/orbit.apk", b"InstallSnapshotReceiver", + b"INSTALL_SNAPSHOT", b"PlaybackTestActivity", b"orbit_play_test", b"orbit_shadow_catalogue", b"orbit_provider_catalogue", + b"orbit_frame_rate", b"orbit_avi", b"PlaytestFileActivity", b"playtest-approved", b"appboxmanager"] +for label, path in (("Play APK", play_apk), ("Play bundle", play_aab)): + found = [f.decode() for f in forbidden if f in dex(path)] + if found: problems.append(f"{label} contains: {', '.join(found)}") +required = [b"android/content/pm/PackageInstaller", b"RoomUpdates", b"InstallSnapshotReceiver", b"orbit_shadow_catalogue"] +missing = [r.decode() for r in required if r not in dex(household_apk)] +if missing: problems.append(f"household APK is missing: {', '.join(missing)}") +for bad in (b"PlaytestFileActivity", b"playtest-approved", b"appboxmanager"): + if bad in dex(household_apk): problems.append(f"household APK contains {bad.decode()}") +# Shared features are in both: Rooms, profiles, Taste, Continue Watching, the Arcade. +for need in (b"RoomSync", b"Profiles", b"TasteEvent", b"ContinueWatching", b"tv/orbit/classic/arcade"): + for label, path in (("household APK", household_apk), ("Play APK", play_apk), ("Play bundle", play_aab)): + if need not in dex(path): problems.append(f"{label} is missing shared {need.decode()}") + +for label, path in (("household APK", household_apk), ("Play APK", play_apk), ("Play bundle", play_aab)): + if signed(path): problems.append(f"{label} is signed") + +if problems: + print("Editions check FAILED:"); [print(" - " + p) for p in problems]; sys.exit(1) +print("Editions check passed: same app id, codes in order, Play isolated, household intact, all unsigned.") diff --git a/tools/known-version-codes.txt b/tools/known-version-codes.txt new file mode 100644 index 00000000..5804d2c8 --- /dev/null +++ b/tools/known-version-codes.txt @@ -0,0 +1,39 @@ +# Every Orbit version code built so far (10 November 2026), from /home/pauljd/Documents/OrbitTV/apks: code package name. +# 390 is the reserved fix-forward recovery build (0.122.1's code). New codes must stay above all of these. +279 tv.orbit.classic 0.110.4-sunday-edition +280 tv.orbit.classic 0.110.5-orbi-fax-trial +281 tv.orbit.classic 0.110.5-arcade-stage-c +290 tv.orbit.classic 0.110.7-arcade1 +291 tv.orbit.classic 0.110.8-arcade1 +292 tv.orbit.classic 0.110.9-combined +293 tv.orbit.classic 0.110.10-household +295 tv.orbit.classic 0.110.12-story-p1000 +296 tv.orbit.classic 0.110.13-story-p1000 +297 tv.orbit.classic 0.110.14-chaos +298 tv.orbit.classic 0.110.15-smartsetup +299 tv.orbit.classic 0.110.16-chaos-smartsetup +300 tv.orbit.classic 0.110.17-chaos-smartsetup +301 tv.orbit.classic 0.111.0-classics-family +302 tv.orbit.classic 0.112.0-signal-run +303 tv.orbit.classic 0.113.0-classic-challenges +304 tv.orbit.classic 0.114.0-classic-modes +305 tv.orbit.classic 0.115.0-night-shift +306 tv.orbit.classic 0.116.0-orbiteroids +307 tv.orbit.classic 0.116.1-orbiteroids +308 tv.orbit.classic 0.117.0-quiz-night +309 tv.orbit.classic 0.118.0-new-originals +310 tv.orbit.classic 0.119.0-orbit-rush +311 tv.orbit.classic 0.120.0-sound-kit +312 tv.orbit.classic 0.121.0-house-scores +313 tv.orbit.classic 0.122.0-orbit-rush +314 tv.orbit.classic 0.122.1-smooth-row +315 tv.orbit.classic 0.123.0-player +316 tv.orbit.classic 0.123.1-player +317 tv.orbit.classic 0.124.0-improvements +318 tv.orbit.classic 0.124.1-guide +319 tv.orbit.classic 0.124.2-guide +320 tv.orbit.classic 0.124.3-follow +321 tv.orbit.classic 0.124.4-follow +322 tv.orbit.classic 0.125.0-taste2 +323 tv.orbit.classic 0.126.0-noserver +390 tv.orbit.classic 0.122.1-fixforward diff --git a/tools/verify.sh b/tools/verify.sh index acb91b7a..7f976b65 100755 --- a/tools/verify.sh +++ b/tools/verify.sh @@ -1,7 +1,8 @@ #!/usr/bin/env bash # Orbit's release gate (8 November 2026): the same checks for every change and every provider, before anything reaches a TV. -# Builds the release APK, runs every unit test (the shared provider contract suite included) and lint, and fails on any -# failure, any lint error, or a missing contract suite. Prints the APK's SHA-256 for the install record. +# Builds both editions (household APK, Play APK and Play bundle, all unsigned), runs every unit test for both (the shared +# provider contract suite included) and lint, and fails on any failure, any lint error, a missing contract suite, or an +# editions check that fails (tools/check_editions.py). Prints the SHA-256s for the install record. # tools/verify.sh (uses Orbit's offline .tooling cache when it's there) set -euo pipefail ROOT="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)" @@ -13,21 +14,27 @@ python3 "$ROOT/tools/test_compare_snapshots.py" 2>&1 | tail -1 # the install c cd "$ROOT/android" # A clean build every time (9 November 2026): incremental builds left stale Compose stability checks in the APK. ./gradlew --no-daemon "${OFFLINE[@]}" -q clean -./gradlew --no-daemon "${OFFLINE[@]}" -q :app:assembleRelease :app:testDebugUnitTest --rerun :app:lintRelease +./gradlew --no-daemon "${OFFLINE[@]}" -q :app:assembleHouseholdRelease :app:assemblePlayRelease :app:bundlePlayRelease \ + :app:testHouseholdDebugUnitTest :app:testPlayDebugUnitTest --rerun :app:lintHouseholdRelease :app:lintPlayRelease python3 - <<'PY' import glob, re, sys -tests = fails = 0; contract = False -for p in glob.glob('app/build/test-results/testDebugUnitTest/*.xml'): - s = open(p).read(); m = re.search(r'tests="(\d+)".*?failures="(\d+)".*?errors="(\d+)"', s) - tests += int(m[1]); fails += int(m[2]) + int(m[3]) - if 'ContractTest' in p and 'MediaProviderContract' not in p: contract = True -lint = len(re.findall(r'severity="(Error|Fatal)"', open('app/build/reports/lint-results-release.xml').read())) -print(f"tests {tests}, failures {fails}, lint errors {lint}, contract suite {'present' if contract else 'MISSING'}") -sys.exit(0 if fails == 0 and lint == 0 and contract and tests > 0 else 1) +ok = True +for edition in ("Household", "Play"): + tests = fails = 0; contract = False + for p in glob.glob(f'app/build/test-results/test{edition}DebugUnitTest/*.xml'): + s = open(p).read(); m = re.search(r'tests="(\d+)".*?failures="(\d+)".*?errors="(\d+)"', s) + tests += int(m[1]); fails += int(m[2]) + int(m[3]) + if 'ContractTest' in p and 'MediaProviderContract' not in p: contract = True + lint = len(re.findall(r'severity="(Error|Fatal)"', open(f'app/build/reports/lint-results-{edition.lower()}Release.xml').read())) + print(f"{edition.lower()}: tests {tests}, failures {fails}, lint errors {lint}, contract suite {'present' if contract else 'MISSING'}") + ok = ok and fails == 0 and lint == 0 and contract and tests > 0 +sys.exit(0 if ok else 1) PY -# The playback test hook is only ever in the playtest build (Paul, 9 November 2026): never in the release APK. -if unzip -l app/build/outputs/apk/release/app-release.apk | grep -q playtest-approved || \ - unzip -p app/build/outputs/apk/release/app-release.apk 'classes*.dex' | grep -aq PlaytestFileActivity; then echo "Release APK contains the playback test hook."; exit 1; fi -if unzip -p app/build/outputs/apk/release/app-release.apk 'classes*.dex' 'assets/*' | grep -aq appboxmanager; then echo "Release APK contains a built-in server address."; exit 1; fi -sha256sum app/build/outputs/apk/release/app-release.apk | cut -c1-64 +HOUSEHOLD=app/build/outputs/apk/household/release/app-household-release-unsigned.apk +PLAY=app/build/outputs/apk/play/release/app-play-release-unsigned.apk +BUNDLE=app/build/outputs/bundle/playRelease/app-play-release.aab +# Both editions as built (Paul, 10 November 2026): ids, version codes, Play isolation, household intact, nothing signed. +# The playback test hook and any server address are refused in every edition there too. +python3 "$ROOT/tools/check_editions.py" "$HOUSEHOLD" "$PLAY" "$BUNDLE" "$(ls -d "$ANDROID_HOME"/build-tools/* | sort -V | tail -1)/aapt2" +sha256sum "$HOUSEHOLD" "$PLAY" "$BUNDLE" | sed "s#app/build/outputs/##" echo "Release gate passed."