M2: loading bar, live URL sync, fwd state, autocomplete suggestions

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

@@ -12,6 +12,9 @@ import androidx.compose.foundation.lazy.items
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.viewinterop.AndroidView
 import org.mozilla.geckoview.GeckoResult
@@ -108,26 +111,38 @@ class BrowserActivity : ComponentActivity() {
     }
 
     // ------------------------------------------------------------------
-    // UI (M1: shell + tab tray; toolbar polish remains an M2 milestone)
+    // UI (M2: toolbar polish; extension manager UI is the M3 milestone)
     // ------------------------------------------------------------------
     @Composable
     private fun NovaUI() {
         var urlInput by remember { mutableStateOf("https://example.com") }
+        var urlFocused by remember { mutableStateOf(false) }
         var trayOpen by remember { mutableStateOf(false) }
         val geckoView = remember { GeckoView(this) }
+        val focusManager = LocalFocusManager.current
         val activeId by tabManager.activeTabId
-        val canGoBack by remember {
-            derivedStateOf { tabManager.canGoBack() }
-        }
 
-        // Switch the engine view whenever the active tab changes.
+        val canGoBack by remember { derivedStateOf { tabManager.canGoBack() } }
+        val canGoForward by remember { derivedStateOf { tabManager.canGoForward() } }
+
+        // M2: loading state + progress of the active tab
+        val loading = activeId != null && tabManager.loadingStates[activeId!!] == true
+        val progress = activeId?.let { tabManager.progressStates[it] } ?: 0
+
+        // M2: live URL sync — follow the active tab's navigation while the
+        // user is not editing the address bar.
+        val activeUrl = activeId?.let { tabManager.lastUrls[it] }
         LaunchedEffect(activeId) {
             val id = activeId ?: return@LaunchedEffect
             val tab = tabManager.tabs.firstOrNull { t -> t.id == id } ?: return@LaunchedEffect
             geckoView.setSession(tab.session)
-            // Sync the URL bar with the tab we just activated.
-            tabManager.lastUrls[id]?.let { urlInput = it }
         }
+        LaunchedEffect(activeUrl) {
+            if (!urlFocused && activeUrl != null) urlInput = activeUrl
+        }
+
+        // M2: autocomplete suggestions from history while typing
+        val suggestions = if (urlFocused) tabManager.suggestionsFor(urlInput) else emptyList()
 
         if (trayOpen) {
             TabTray(
@@ -146,22 +161,67 @@ class BrowserActivity : ComponentActivity() {
             OutlinedTextField(
                 value = urlInput,
                 onValueChange = { urlInput = it },
-                modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 4.dp),
+                onNavigateToSuggestion = null,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 8.dp, vertical = 4.dp)
+                    .onFocusChanged { urlFocused = it.isFocused },
                 label = { Text("Search or enter address") },
                 singleLine = true,
             )
+
+            // Autocomplete dropdown (history matches, most recent first)
+            if (urlFocused && suggestions.isNotEmpty()) {
+                Surface(
+                    tonalElevation = 4.dp,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(horizontal = 8.dp),
+                ) {
+                    Column {
+                        suggestions.forEach { suggestion ->
+                            TextButton(
+                                onClick = {
+                                    urlInput = suggestion
+                                    urlFocused = false
+                                    focusManager.clearFocus()
+                                    tabManager.activeSession()?.loadUri(suggestion)
+                                },
+                                modifier = Modifier.fillMaxWidth(),
+                            ) {
+                                Text(suggestion, maxLines = 1, overflow = TextOverflow.Ellipsis)
+                            }
+                        }
+                    }
+                }
+            }
+
             Row(Modifier.padding(horizontal = 8.dp)) {
                 TextButton(
                     onClick = { tabManager.activeSession()?.goBack() },
                     enabled = canGoBack,
                 ) { Text("◀") }
-                TextButton(onClick = { tabManager.activeSession()?.goForward() }) { Text("▶") }
+                TextButton(
+                    onClick = { tabManager.activeSession()?.goForward() },
+                    enabled = canGoForward,
+                ) { Text("▶") }
                 TextButton(onClick = { tabManager.activeSession()?.reload() }) { Text("��") }
-                TextButton(onClick = { tabManager.activeSession()?.loadUri(normalize(urlInput)) }) { Text("Go") }
+                TextButton(onClick = {
+                    focusManager.clearFocus()
+                    tabManager.activeSession()?.loadUri(normalize(urlInput))
+                }) { Text("Go") }
                 TextButton(onClick = { tabManager.open("about:blank") }) { Text("+") }
                 TextButton(onClick = { trayOpen = true }) { Text("Tabs ${tabManager.tabs.size}") }
             }
 
+            // M2: loading bar for the active tab
+            if (loading) {
+                LinearProgressIndicator(
+                    progress = { progress / 100f },
+                    modifier = Modifier.fillMaxWidth(),
+                )
+            }
+
             // Tab strip
             LazyRow(Modifier.padding(horizontal = 8.dp)) {
                 items(tabManager.tabs, key = { it.id }) { tab ->