M1: session persistence + restore in TabManager

app/src/main/java/dev/nova/browser/TabManager.kt

@@ -1,12 +1,17 @@
 package dev.nova.browser
 
+import android.content.Context
+import android.util.Log
 import androidx.compose.runtime.mutableStateListOf
 import androidx.compose.runtime.mutableStateMapOf
 import androidx.compose.runtime.mutableStateOf
+import org.json.JSONArray
+import org.json.JSONObject
 import org.mozilla.geckoview.GeckoResult
 import org.mozilla.geckoview.GeckoRuntime
 import org.mozilla.geckoview.GeckoSession
 import org.mozilla.geckoview.WebExtension
+import java.io.File
 
 /**
  * Nova's tab model. One GeckoSession per tab; the UI activates a tab by
@@ -15,8 +20,12 @@ import org.mozilla.geckoview.WebExtension
  * GeckoView does not expose canGoBack()/canGoForward() as polling methods —
  * navigation state arrives via NavigationDelegate callbacks, so we track it
  * here per tab.
+ *
+ * M1 session restore: open-tab URLs + the active tab index are persisted to
+ * a JSON file on every tab change and on activity stop, and reloaded on cold
+ * start (URL-level restore; full session-state capture is a later milestone).
  */
-class TabManager(private val runtime: GeckoRuntime) {
+class TabManager(private val runtime: GeckoRuntime, private val context: Context) {
 
     data class Tab(val id: Int, val session: GeckoSession)
 
@@ -35,6 +44,10 @@ class TabManager(private val runtime: GeckoRuntime) {
     val consoleLines = mutableStateListOf<String>()
 
     private var nextId = 1
+    private var restoring = false
+
+    private val stateFile: File
+        get() = File(context.filesDir, "session_state.json")
 
     /** Per-session content-script message delegate ("browser" native app). */
     private val sessionMessageDelegate = object : WebExtension.MessageDelegate {
@@ -60,7 +73,10 @@ class TabManager(private val runtime: GeckoRuntime) {
                 perms: List<GeckoSession.PermissionDelegate.ContentPermission>,
                 hasUserGesture: Boolean,
             ) {
-                if (url != null) lastUrls[tabId] = url
+                if (url != null) {
+                    lastUrls[tabId] = url
+                    if (!restoring) persistSession()
+                }
             }
 
             override fun onCanGoBack(session: GeckoSession, canGoBack: Boolean) {
@@ -84,11 +100,15 @@ class TabManager(private val runtime: GeckoRuntime) {
         tabs.add(tab)
         activeTabId.value = tab.id
         session.loadUri(url)
+        if (!restoring) persistSession()
         return tab
     }
 
     fun activate(id: Int) {
-        if (tabs.any { it.id == id }) activeTabId.value = id
+        if (tabs.any { it.id == id }) {
+            activeTabId.value = id
+            if (!restoring) persistSession()
+        }
     }
 
     fun close(id: Int) {
@@ -101,6 +121,7 @@ class TabManager(private val runtime: GeckoRuntime) {
         if (activeTabId.value == id) {
             activeTabId.value = tabs.lastOrNull()?.id
         }
+        persistSession()
     }
 
     fun activeSession(): GeckoSession? =
@@ -110,6 +131,57 @@ class TabManager(private val runtime: GeckoRuntime) {
     fun canGoBack(): Boolean =
         activeTabId.value?.let { canGoBackStates[it] == true } ?: false
 
+    // ------------------------------------------------------------------
+    // Session persistence (M1)
+    // ------------------------------------------------------------------
+
+    /** Writes open-tab URLs + active tab index to disk. Cheap and idempotent. */
+    fun persistSession() {
+        try {
+            val arr = JSONArray()
+            var activeIndex = -1
+            tabs.forEach { tab ->
+                val url = lastUrls[tab.id]
+                if (!url.isNullOrBlank()) {
+                    arr.put(JSONObject().put("url", url))
+                    if (tab.id == activeTabId.value) activeIndex = arr.length() - 1
+                }
+            }
+            val obj = JSONObject()
+                .put("tabs", arr)
+                .put("active", activeIndex)
+                .put("savedAt", System.currentTimeMillis())
+            stateFile.writeText(obj.toString())
+        } catch (e: Exception) {
+            Log.w("Nova", "persistSession failed", e)
+        }
+    }
+
+    /** Reopens persisted tabs on cold start. Returns how many were restored. */
+    fun restoreSession(): Int {
+        restoring = true
+        try {
+            if (!stateFile.exists()) return 0
+            val obj = JSONObject(stateFile.readText())
+            val arr = obj.optJSONArray("tabs") ?: return 0
+            val urls = (0 until arr.length())
+                .mapNotNull { i -> arr.optJSONObject(i)?.optString("url") }
+                .filter { it.isNotBlank() }
+            urls.forEach { open(it) }
+            val active = obj.optInt("active", -1)
+            if (active in urls.indices) {
+                tabs.getOrNull(active)?.let { activate(it.id) }
+            }
+            Log.i("Nova", "Restored ${urls.size} tab(s) from session state")
+            return urls.size
+        } catch (e: Exception) {
+            Log.w("Nova", "restoreSession failed — starting fresh", e)
+            return 0
+        } finally {
+            restoring = false
+        }
+    }
+
     /** Called once the built-in extension finishes installing. */
     fun wireExtension(ext: WebExtension) {
         devExtension = ext
@@ -134,6 +206,6 @@ class TabManager(private val runtime: GeckoRuntime) {
             }
         }
         consoleLines.add(line)
-        android.util.Log.i("NovaConsole", line)
+        Log.i("NovaConsole", line)
     }
 }