M2: progress/loading/forward tracking + persisted history store

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

@@ -19,11 +19,14 @@ import java.io.File
  *
  * GeckoView does not expose canGoBack()/canGoForward() as polling methods —
  * navigation state arrives via NavigationDelegate callbacks, so we track it
- * here per tab.
+ * here per tab. Loading state and progress arrive via ProgressDelegate.
  *
  * 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).
+ *
+ * M2 history: committed visits are recorded (most-recent-first, deduped,
+ * capped) into history.json and power the URL bar autocomplete.
  */
 class TabManager(private val runtime: GeckoRuntime, private val context: Context) {
 
@@ -35,8 +38,16 @@ class TabManager(private val runtime: GeckoRuntime, private val context: Context
 
     /** Navigation state per tab id, fed by NavigationDelegate callbacks. */
     val canGoBackStates = mutableStateMapOf<Int, Boolean>()
+    val canGoForwardStates = mutableStateMapOf<Int, Boolean>()
     val lastUrls = mutableStateMapOf<Int, String>()
 
+    /** Loading state per tab id, fed by ProgressDelegate. */
+    val loadingStates = mutableStateMapOf<Int, Boolean>()
+    val progressStates = mutableStateMapOf<Int, Int>()
+
+    /** Visited URLs, most recent first (deduplicated, capped). */
+    val history = mutableStateListOf<String>()
+
     /** Installed built-in extension, wired in once available. */
     var devExtension: WebExtension? = null
 
@@ -49,6 +60,13 @@ class TabManager(private val runtime: GeckoRuntime, private val context: Context
     private val stateFile: File
         get() = File(context.filesDir, "session_state.json")
 
+    private val historyFile: File
+        get() = File(context.filesDir, "history.json")
+
+    init {
+        loadHistory()
+    }
+
     /** Per-session content-script message delegate ("browser" native app). */
     private val sessionMessageDelegate = object : WebExtension.MessageDelegate {
         override fun onMessage(
@@ -82,10 +100,29 @@ class TabManager(private val runtime: GeckoRuntime, private val context: Context
             override fun onCanGoBack(session: GeckoSession, canGoBack: Boolean) {
                 canGoBackStates[tabId] = canGoBack
             }
+
+            override fun onCanGoForward(session: GeckoSession, canGoForward: Boolean) {
+                canGoForwardStates[tabId] = canGoForward
+            }
         }
         session.progressDelegate = object : GeckoSession.ProgressDelegate {
+            override fun onPageStarted(session: GeckoSession, url: String) {
+                loadingStates[tabId] = true
+                progressStates[tabId] = 0
+            }
+
             override fun onProgressChange(session: GeckoSession, progress: Int) {
-                // Hook for the loading bar (M2 milestone).
+                progressStates[tabId] = progress
+            }
+
+            override fun onPageStop(session: GeckoSession, success: Boolean) {
+                loadingStates[tabId] = false
+                if (success) {
+                    progressStates[tabId] = 100
+                    // Committed visits go into history (skips about: pages etc.)
+                    val url = lastUrls[tabId]
+                    if (!restoring && url != null) recordVisit(url)
+                }
             }
         }
 
@@ -117,7 +154,10 @@ class TabManager(private val runtime: GeckoRuntime, private val context: Context
         tabs[index].session.close()
         tabs.removeAt(index)
         canGoBackStates.remove(id)
+        canGoForwardStates.remove(id)
         lastUrls.remove(id)
+        loadingStates.remove(id)
+        progressStates.remove(id)
         if (activeTabId.value == id) {
             activeTabId.value = tabs.lastOrNull()?.id
         }
@@ -127,10 +167,59 @@ class TabManager(private val runtime: GeckoRuntime, private val context: Context
     fun activeSession(): GeckoSession? =
         activeTabId.value?.let { id -> tabs.firstOrNull { it.id == id }?.session }
 
-    /** Whether the active tab can navigate back (delegate-tracked). */
+    /** Whether the active tab can navigate back/forward (delegate-tracked). */
     fun canGoBack(): Boolean =
         activeTabId.value?.let { canGoBackStates[it] == true } ?: false
 
+    fun canGoForward(): Boolean =
+        activeTabId.value?.let { canGoForwardStates[it] == true } ?: false
+
+    // ------------------------------------------------------------------
+    // History (M2)
+    // ------------------------------------------------------------------
+
+    fun recordVisit(url: String) {
+        if (url.startsWith("about:") || url.startsWith("data:") || url.startsWith("javascript:")) return
+        history.remove(url)
+        history.add(0, url)
+        while (history.size > MAX_HISTORY) history.removeAt(history.lastIndex)
+        persistHistory()
+    }
+
+    /** Substring matches against history, most recent first. */
+    fun suggestionsFor(query: String): List<String> {
+        val q = query.trim()
+        if (q.isBlank() || q.startsWith("about:")) return emptyList()
+        return history
+            .filter { it != q && it.contains(q, ignoreCase = true) }
+            .take(MAX_SUGGESTIONS)
+    }
+
+    private fun persistHistory() {
+        try {
+            val arr = JSONArray()
+            history.forEach { arr.put(it) }
+            File(context.filesDir, "history.json").writeText(arr.toString())
+        } catch (e: Exception) {
+            Log.w("Nova", "persistHistory failed", e)
+        }
+    }
+
+    private fun loadHistory() {
+        try {
+            val f = File(context.filesDir, "history.json")
+            if (!f.exists()) return
+            val arr = JSONArray(f.readText())
+            history.clear()
+            for (i in 0 until arr.length()) {
+                val url = arr.optString(i)
+                if (url.isNotBlank()) history.add(url)
+            }
+        } catch (e: Exception) {
+            Log.w("Nova", "loadHistory failed — starting with empty history", e)
+        }
+    }
+
     // ------------------------------------------------------------------
     // Session persistence (M1)
     // ------------------------------------------------------------------
@@ -208,4 +297,9 @@ class TabManager(private val runtime: GeckoRuntime, private val context: Context
         consoleLines.add(line)
         Log.i("NovaConsole", line)
     }
+
+    companion object {
+        private const val MAX_HISTORY = 500
+        private const val MAX_SUGGESTIONS = 5
+    }
 }