chore(v1.22): FileLogger flight recorder — ROM filters logcat, gate/overlay/force-stop/fuse events now logged to app external dir

Author: alex-hermes-agent

app/build.gradle.kts

@@ -15,8 +15,8 @@ android {
         applicationId = "com.alexk.tvlock"
         minSdk = 21
         targetSdk = 34
-        versionCode = 22
-        versionName = "1.21"
+        versionCode = 23
+        versionName = "1.22"
     }
 
     if (!releaseKeystore.isNullOrBlank()) {

app/src/main/java/com/alexk/tvlock/FileLogger.kt

@@ -0,0 +1,57 @@
+package com.alexk.tvlock
+
+import android.content.Context
+import android.os.SystemClock
+import java.io.File
+import java.io.FileWriter
+
+/**
+ * File-based event log.
+ *
+ * Why: the Rockteck ROM filters third-party apps' logcat output entirely —
+ * Log.i/w/e from LockPollService never reach `adb logcat`, so field races
+ * (fast-button press) were unmeasurable. This appends to
+ * <externalFiles>/tvlock.log, which adb shell can read without root.
+ *
+ * Kept deliberately cheap: one line per event, monotonic clock + wall time,
+ * file trimmed when it grows past 256 KB. Every gate-lifecycle decision point
+ * writes here; treat it as the flight recorder.
+ */
+object FileLogger {
+
+    @Volatile private var writer: FileWriter? = null
+    @Volatile private var logFile: File? = null
+
+    fun init(context: Context) {
+        try {
+            val dir = context.getExternalFilesDir(null) ?: context.filesDir
+            logFile = File(dir, "tvlock.log")
+            if ((logFile?.length() ?: 0L) > TRIM_AT) logFile?.delete()
+            writer = FileWriter(logFile, true)
+            android.util.Log.i("TVLOCK", "file logger at ${logFile?.absolutePath}")
+        } catch (e: Exception) {
+            android.util.Log.e("TVLOCK", "file logger init failed", e)
+        }
+    }
+
+    fun log(msg: String) {
+        android.util.Log.i("TVLOCK", msg) // still emit in case logcat works on other ROMs
+        val w = writer ?: return
+        try {
+            synchronized(w) {
+                w.write("${System.currentTimeMillis()} up=${SystemClock.elapsedRealtime()} $msg\n")
+                w.flush()
+            }
+            val f = logFile
+            if (f != null && f.length() > TRIM_AT) {
+                synchronized(w) {
+                    runCatching { w.close() }
+                    f.delete()
+                    writer = FileWriter(f, true).also { writer = it }
+                }
+            }
+        } catch (_: Exception) { /* never break the lock over logging */ }
+    }
+
+    private const val TRIM_AT = 256L * 1024
+}

app/src/main/java/com/alexk/tvlock/GateOverlay.kt

@@ -49,7 +49,15 @@ object GateOverlay {
         try {
             wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
             val root = object : android.widget.FrameLayout(context) {
-                override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean = true
+                override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
+                    // dedicated launch buttons arrive here if the ROM dispatches
+                    // to the focused window; if the child still reaches YouTube,
+                    // these lines prove the interception either does or doesn't happen
+                    if (keyCode == 268 || keyCode == KeyEvent.KEYCODE_MENU) {
+                        FileLogger.log("overlay swallowed key $keyCode")
+                    }
+                    return true
+                }
                 override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean = true
                 override fun onTouchEvent(event: MotionEvent): Boolean = true
             }
@@ -84,9 +92,9 @@ object GateOverlay {
             root.requestFocus()
             view = root
             shownAt = now
-            android.util.Log.i("TVLOCK", "blackout overlay shown")
+            FileLogger.log("overlay SHOW")
         } catch (e: Exception) {
-            android.util.Log.e("TVLOCK", "overlay show FAILED", e)
+            FileLogger.log("overlay show FAILED: ${e.javaClass.simpleName}: ${e.message}")
             view = null
         }
     }
@@ -96,9 +104,9 @@ object GateOverlay {
         view = null
         try {
             wm?.removeView(v)
-            android.util.Log.i("TVLOCK", "blackout overlay hidden")
+            FileLogger.log("overlay HIDE (was up ${System.currentTimeMillis() - shownAt}ms)")
         } catch (e: Exception) {
-            android.util.Log.e("TVLOCK", "overlay hide FAILED", e)
+            FileLogger.log("overlay hide FAILED: ${e.javaClass.simpleName}: ${e.message}")
         }
     }
 }

app/src/main/java/com/alexk/tvlock/LockPollService.kt

@@ -48,6 +48,8 @@ class LockPollService : Service() {
     override fun onCreate() {
         super.onCreate()
         instance = this
+        FileLogger.init(this)
+        FileLogger.log("service onCreate")
         handler = Handler(Looper.getMainLooper())
         usm = getSystemService(USAGE_STATS_SERVICE) as UsageStatsManager
         LockNotification.makeChannel(this)
@@ -98,7 +100,7 @@ class LockPollService : Service() {
         // Hard cap: the blackout must never outlive gate logic under any
         // circumstance, even a bug — an unremovable black screen is a brick.
         if (GateOverlay.isShown && now - GateOverlay.shownAt > OVERLAY_MAX_MS) {
-            android.util.Log.w("TVLOCK", "overlay hard cap — forcing hide")
+            FileLogger.log("overlay HARD CAP 10s — forcing hide (hold=$blackoutHold gateUp=$gateUp top=$t)")
             blackoutHold = false
             GateOverlay.hide()
         }
@@ -122,6 +124,7 @@ class LockPollService : Service() {
                     // the gate never confirmed by the watchdog deadline, retry
                     // raising it — the overlay keeps the screen dead meanwhile.
                     if (now - gateRaisedAt > GATE_CONFIRM_MS) {
+                        FileLogger.log("hold: gate retry (top=$t launcher-state)")
                         targetPkg?.let { raiseGate(it, now) }
                     }
                     return
@@ -162,7 +165,7 @@ class LockPollService : Service() {
             // evTs = the event's own timestamp; now-evTs = how late UsageStats
             // surfaced it to us. This is the detection gap the overlay has to
             // beat on a fast dedicated-button press.
-            android.util.Log.i("TVLOCK", "detect lag=${now - evTs}ms pkg=$t")
+            FileLogger.log("DETECT lag=${now - evTs}ms pkg=$t")
             raiseGate(t, now)
         }
     }
@@ -199,11 +202,11 @@ class LockPollService : Service() {
                         am.javaClass.getMethod("forceStopPackage", String::class.java, Int::class.java)
                             .invoke(am, t, 0)
                         blackoutHold = true
-                        android.util.Log.i("TVLOCK", "force-stopped $t under blackout — holding")
+                        FileLogger.log("force-stop $t OK — blackout HOLDING")
                     } catch (e: Exception) {
                         // hidden API blocked on this ROM (likely on API 34) — the
                         // blackout + gate still protect; this is best-effort only
-                        android.util.Log.w("TVLOCK", "force-stop unavailable: ${e.javaClass.simpleName}")
+                        FileLogger.log("force-stop DENIED: ${e.javaClass.simpleName}")
                     }
                 }
             }, 500)