2.7.1: audit fixes, accurate daily-recorded weeks, and a smaller APK

.github/workflows/android.yml

@@ -42,11 +42,13 @@ jobs:
       - name: Test, lint, and build unsigned verification release
         run: >
           ./gradlew
-          :protocol:testDebugUnitTest
+          :protocol:test
           :app:testDebugUnitTest
           :app:lintDebug
           :app:assembleRelease
           -PallowUnsignedRelease=true
+          -x :app:lintVitalRelease
+          -x :app:lintVitalAnalyzeRelease
           --no-daemon
           --stacktrace
 

.github/workflows/codeql.yml

@@ -107,7 +107,7 @@ jobs:
         run: >
           ./gradlew
           :app:compileDebugKotlin
-          :protocol:compileDebugKotlin
+          :protocol:compileKotlin
           --init-script .github/codeql/codeql-kotlin-compat.init.gradle
           --rerun-tasks
           --no-build-cache

.github/workflows/deploy-pages.yml

@@ -3,6 +3,11 @@ name: Deploy project page to GitHub Pages
 on:
   push:
     branches: ["main"]
+    # The page is built from the READMEs alone.
+    paths:
+      - README.md
+      - README_KR.md
+      - .github/workflows/deploy-pages.yml
   workflow_dispatch:
 
 permissions:

CHANGELOG.md

@@ -2,6 +2,74 @@
 
 All notable changes to mobileGF2logger are documented here.
 
+## 2.7.1 - 2026-10-25
+
+### Fixed
+
+- Stop a scheduled recording from turning the screen off again about ten
+  minutes after it finished, while the phone is in use.
+- Keep every day of a Gunsmoke Frontline week filled when it is recorded once a
+  day before the reset: when the exact search gives up, the rest of the week now
+  continues with safe lower bounds and exact weekly totals instead of dropping
+  later days.
+- Treat a capture at exactly the Sunday 05:00 reset as the closing evidence of
+  the ending week, keep Standard days at or below the 90-point daily cap, credit
+  a mid-week joiner's merit from the day after they were last absent, and leave
+  an open final Saturday's patrol unknown instead of missed.
+- Show roster comparison deltas across a weekly reset as lower bounds; the
+  comparison CSV gains two certainty columns.
+- Report capture as stopped only after its teardown finishes, so backup,
+  restore, CSV import and undo, and Platoon changes started with "Stop capture
+  and continue" never overlap the last packets; Home shows "Stopping capture"
+  meanwhile.
+- Refuse a CSV undo when newer data arrived after its check, recover
+  interrupted CSV imports at startup and before capture, roll back a failed
+  restore under the same lock, and never crash at launch over a recovery.
+- Show capture notifications and background messages in the app's chosen
+  language.
+- Reject roster CSV files dated in the future.
+- Exclude the management database from Android cloud backup and device
+  transfer, as documented.
+- Ignore Discard while weekly edits are saving, and save exactly the edits that
+  were tapped.
+- Keep member, order, comparison, cutline and history screens open, with their
+  unsaved edits, when only the Platoon's name or banner changes.
+- Avoid a crash on phones without the battery-optimization dialog and an empty
+  server choice after VPN consent when entering standby mode.
+- Close the game from Recents reliably on launchers whose Recents opens slowly.
+- Start every automatic recording with a fresh game: a client left in the
+  background from earlier is closed from Recents first, since resuming it can
+  stop at a "reconnection failed" notice no automatic tap may press.
+- Refresh the Platoon and Weekly screens when a roster is saved while they are
+  open, keep their scroll position across recreation, and clear stale rows after
+  a failed load.
+- Keep the new-Platoon prompt open while a confirmation runs, show why it
+  failed, and move it to the screen that just opened; a retried confirmation no
+  longer duplicates history files.
+- Declare the capture VPN unmetered, clean up unfinished roster files, bound
+  stored diagnostics, and tell TLS from game traffic only by a full record
+  header.
+- Date an inferred join or withdrawal from activity only between the rosters
+  around the change, order weekly history by recording order instead of the
+  clock, keep a crash-left journal with a restore's rollback copy, and never
+  delete a Platoon that was registered again while its deletion was queued.
+- Save weekly cutlines off the main thread, report a failed packet deletion,
+  refuse clipboard copies over the system limit, show only the start of huge raw
+  packets, and ask before removing the Discord webhook (kept through passing
+  Keystore errors).
+- Keep top and bottom bars at full height under the system bars, ellipsize long
+  capture notices, and finish pending Platoon deletions off the main thread.
+
+### Changed
+
+- Shrink the release APK from 3.2 MB to 1.1 MB: the Platoon emblem and launcher
+  artwork ship as lossless WebP at the largest size they are drawn, legacy
+  launcher PNGs and unused metadata are gone, and v1 JAR signing is off.
+- Build the protocol module as a plain Kotlin library and skip the duplicate
+  release lint pass in CI.
+- Reuse one scan of the Platoon's weeks for member edits, and remove dead
+  weekly-note and render bookkeeping paths.
+
 ## 2.7.0 - 2026-10-25
 
 ### Added

PRODUCT.md

@@ -65,7 +65,7 @@ is the binding visual direction for the v2.3.0 frontend:
   feature guidance, visible progress, top-right Skip, and bottom navigation.
 
 The shipped emblem remains the existing launcher artwork at
-`app/src/main/res/drawable-nodpi/ic_launcher_art.png`.
+`app/src/main/res/drawable-nodpi/ic_launcher_art.webp`.
 
 ## Design principles
 

app/build.gradle

@@ -154,8 +154,8 @@ android {
         applicationId = 'dev.gf2log'
         minSdk = 26
         targetSdk = 36
-        versionCode = 20700
-        versionName = '2.7.0'
+        versionCode = 20701
+        versionName = '2.7.1'
         testInstrumentationRunner = 'androidx.test.runner.AndroidJUnitRunner'
 
         ndk {
@@ -178,7 +178,8 @@ android {
                 storePassword = releaseSigningProperties.getProperty('storePassword')
                 keyAlias = releaseSigningProperties.getProperty('keyAlias')
                 keyPassword = releaseSigningProperties.getProperty('keyPassword')
-                enableV1Signing = true
+                // minSdk 26 verifies v2+ signatures; the JAR (v1) signature only adds bytes.
+                enableV1Signing = false
                 enableV2Signing = true
                 enableV3Signing = true
                 enableV4Signing = true
@@ -209,6 +210,19 @@ android {
         }
     }
 
+    packaging {
+        resources {
+            // Kotlin reflection metadata and library version/licence stamps; nothing reads them at
+            // run time (no kotlin-reflect, no coroutines debug probes).
+            excludes += [
+                '**/*.kotlin_builtins',
+                'DebugProbesKt.bin',
+                'META-INF/*.version',
+                'META-INF/androidx/**/LICENSE.txt',
+            ]
+        }
+    }
+
     bundle {
         language {
             enableSplit = false

app/src/androidTest/java/dev/gf2log/app/management/PlatoonBackupManagerIntegrationTest.kt

@@ -26,6 +26,7 @@ import dev.gf2log.protocol.model.GuildMember
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
 import java.io.EOFException
+import java.io.File
 import java.io.InputStream
 import java.time.Instant
 import java.time.LocalDate
@@ -314,6 +315,62 @@ class PlatoonBackupManagerIntegrationTest {
         assertFalse(FilePaths.preRestoreDatabase(context).exists())
     }
 
+    @Test
+    fun failedRestoreKeepsTheWalACrashLeftBesideTheCurrentDatabase() {
+        seedDatabase(ARCHIVED_UID, "Archived member", "archived-source.csv")
+        val archive = ByteArrayOutputStream().also {
+            PlatoonBackupManager(context).exportFull(it)
+        }.toByteArray()
+        replaceDatabaseWithCurrentState()
+        settingsStore.replace(currentSettings())
+        val databaseFile = context.getDatabasePath(storageScope.databaseName)
+        val crashCopy = File(context.cacheDir, "crash-left-database").apply {
+            deleteRecursively()
+            check(mkdirs())
+        }
+        PlatoonRepository.withExclusiveDatabase(storageScope) {
+            // Copying the files while the WAL connection is open leaves the committed update
+            // only in the WAL, as a process death before the next checkpoint would.
+            SQLiteDatabase.openDatabase(
+                databaseFile.path,
+                null,
+                SQLiteDatabase.OPEN_READWRITE or SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING,
+            ).use { db ->
+                db.rawQuery("PRAGMA wal_autocheckpoint = 0", null).use { it.moveToFirst() }
+                db.execSQL(
+                    "UPDATE members SET note = ? WHERE uid = ?",
+                    arrayOf<Any>(CRASH_LEFT_NOTE, CURRENT_UID),
+                )
+                databaseFile.copyTo(File(crashCopy, "database"))
+                File(databaseFile.path + "-wal").copyTo(File(crashCopy, "wal"))
+            }
+            assertTrue(context.deleteDatabase(storageScope.databaseName))
+            File(crashCopy, "database").copyTo(databaseFile)
+            File(crashCopy, "wal").copyTo(File(databaseFile.path + "-wal"))
+        }
+        crashCopy.deleteRecursively()
+
+        assertThrows(IllegalStateException::class.java) {
+            PlatoonBackupManager(
+                context = context,
+                settingsStore = settingsStore,
+                restoreObserver = { checkpoint ->
+                    if (checkpoint == PlatoonBackupManager.RestoreCheckpoint.DATABASE_INSTALLED) {
+                        error("simulated restore failure")
+                    }
+                },
+            ).restoreFull(ByteArrayInputStream(archive))
+        }
+
+        PlatoonDatabase(context).use { database ->
+            val db = database.readableDatabase
+            assertEquals(1L, count(db, "members", "note = ?", CRASH_LEFT_NOTE))
+            assertEquals(0L, count(db, "members", "uid = ?", ARCHIVED_UID))
+        }
+        assertFalse(FilePaths.preRestoreDatabase(context).exists())
+        assertFalse(File(FilePaths.preRestoreDatabase(context).path + "-wal").exists())
+    }
+
     @Test
     fun freshInstallFailureRestoresTheMissingDatabaseState() {
         seedDatabase(ARCHIVED_UID, "Archived member", "archived-source.csv")
@@ -686,6 +743,57 @@ class PlatoonBackupManagerIntegrationTest {
         assertFalse(FilePaths.csvCheckpointDirectory(context).exists())
     }
 
+    @Test
+    fun checkpointInstallRefusesADatabaseThatChangedSinceTheUndoCheck() {
+        seedDatabase(ARCHIVED_UID, "Before import", "before-import.csv")
+        val checkpoint = ByteArrayOutputStream().also { output ->
+            PlatoonBackupManager(context, storageScope).export(output)
+        }.toByteArray()
+        val manager = PlatoonBackupManager(context, storageScope)
+        val checkedDigest = manager.currentDatabaseSha256()
+        // A capture ingests after the undo's own digest check but before the install.
+        replaceDatabaseForCheckpoint(CURRENT_UID, "Newer capture", "newer-capture.csv")
+
+        assertThrows(IllegalStateException::class.java) {
+            manager.restoreCheckpoint(ByteArrayInputStream(checkpoint), checkedDigest)
+        }
+
+        PlatoonDatabase(context).use { database ->
+            assertEquals(1L, count(database.readableDatabase, "members", "uid = ?", CURRENT_UID))
+            assertEquals(0L, count(database.readableDatabase, "members", "uid = ?", ARCHIVED_UID))
+        }
+        assertFalse(FilePaths.restoreTransactionDirectory(context).exists())
+    }
+
+    @Test
+    fun startupRecoveryFinishesInterruptedImportsAndSurvivesABrokenScope() {
+        seedDatabase(ARCHIVED_UID, "Before interrupted import", "before-interrupted-import.csv")
+        val checkpoint = FilePaths.csvCheckpointDirectory(context)
+        assertTrue(checkpoint.mkdirs())
+        java.io.FileOutputStream(java.io.File(checkpoint, "platoon.gf2backup")).use { output ->
+            PlatoonBackupManager(context).export(output)
+        }
+        java.io.File(checkpoint, "planned-files.txt").writeText("\n", Charsets.UTF_8)
+        replaceDatabaseForCheckpoint(CURRENT_UID, "Interrupted import", "interrupted-import.csv")
+        val brokenScope = PlatoonStorageScope(
+            PlatoonProfileRegistry(context).upsertDetected(
+                SupportedGamePackages.DARKWINTER,
+                GameServerRegion.DARKWINTER_GLOBAL,
+                dev.gf2log.protocol.model.PlatoonProfileData(303u, "Broken checkpoint", 0u, 0u),
+            ).storageId,
+        )
+        // A checkpoint without its archive cannot be recovered and must not stop the others.
+        assertTrue(java.io.File(brokenScope.rootDirectory(context), "csv-import-checkpoint").mkdirs())
+
+        assertEquals(1, CsvImportCheckpointManager.recoverInterruptedImports(context))
+
+        PlatoonDatabase(context).use { database ->
+            assertEquals(1L, count(database.readableDatabase, "members", "uid = ?", ARCHIVED_UID))
+            assertEquals(0L, count(database.readableDatabase, "members", "uid = ?", CURRENT_UID))
+        }
+        assertFalse(checkpoint.exists())
+    }
+
     @Test
     fun malformedCompleteBackupDoesNotMutateExistingState() {
         seedDatabase(CURRENT_UID, "Current member", "current-source.csv")
@@ -1182,6 +1290,7 @@ class PlatoonBackupManagerIntegrationTest {
         const val CURRENT_UID = 2002L
         const val THIRD_UID = 3003L
         const val ARCHIVED_NOTE = "Weekly review"
+        const val CRASH_LEFT_NOTE = "Committed only to the WAL"
         const val INVALID_TARGET_PACKAGE = "not a package"
         val PERIOD_START: LocalDate = LocalDate.of(2026, 7, 26)
     }