BrowserActivity: runtime, Compose UI, native messaging

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

@@ -0,0 +1,166 @@
+package dev.nova.browser
+
+import android.os.Bundle
+import android.util.Log
+import androidx.activity.ComponentActivity
+import androidx.activity.OnBackPressedCallback
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import org.mozilla.geckoview.GeckoRuntime
+import org.mozilla.geckoview.GeckoView
+import org.mozilla.geckoview.WebExtension
+
+class BrowserActivity : ComponentActivity() {
+
+    companion object {
+        // GeckoRuntime must be created exactly once per process (see GeckoView quick-start).
+        private var runtime: GeckoRuntime? = null
+    }
+
+    private lateinit var tabManager: TabManager
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        if (runtime == null) {
+            runtime = GeckoRuntime.create(this)
+            // Layer 2 of the dev console: desktop Firefox DevTools can attach
+            // via about:debugging over USB / Wi-Fi.
+            runtime!!.settings.setDebugSupportEnabled(true)
+        }
+        tabManager = TabManager(runtime!!)
+
+        installDevConsoleExtension()
+
+        // Hardware back button: navigate the page back before leaving the app.
+        onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
+            override fun handleOnBackPressed() {
+                val session = tabManager.activeSession()
+                if (session != null && session.canGoBack()) session.goBack() else finish()
+            }
+        })
+
+        setContent { NovaUI() }
+
+        tabManager.open("https://example.com")
+    }
+
+    /**
+     * Installs the bundled dev-console extension (idempotent) and wires the
+     * background-script native messaging channel.
+     */
+    private fun installDevConsoleExtension() {
+        val controller = runtime!!.webExtensionController
+        controller.ensureBuiltIn("resource://android/assets/devconsole/", "devconsole@nova")
+            .accept(
+                { ext ->
+                    Log.i("Nova", "Dev-console extension installed: ${ext?.id}")
+                    ext?.let {
+                        // Background script -> app channel.
+                        it.setMessageDelegate(NovaBackgroundMessageDelegate(), "browser")
+                        tabManager.wireExtension(it)
+                    }
+                },
+                { e -> Log.e("Nova", "Failed to install dev-console extension", e) }
+            )
+    }
+
+    /** Receives messages from the extension's background script. */
+    private inner class NovaBackgroundMessageDelegate : WebExtension.MessageDelegate {
+        override fun onMessage(
+            nativeApp: String,
+            message: Any,
+            sender: WebExtension.MessageSender
+        ): GeckoResult<Any>? {
+            tabManager.recordConsoleMessage(message)
+            return null
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // UI (Compose shell — M0 scope; toolbar/tabs polish are later milestones)
+    // ------------------------------------------------------------------
+    @Composable
+    private fun NovaUI() {
+        var urlInput by remember { mutableStateOf("https://example.com") }
+        val geckoView = remember { GeckoView(this) }
+        val activeId by tabManager.activeTabId
+
+        // Switch the engine view whenever the active tab changes.
+        LaunchedEffect(activeId) {
+            activeId?.let { id ->
+                tabManager.tabs.firstOrNull { it.id == id }?.let { geckoView.setSession(it.session) }
+            }
+        }
+
+        Column(Modifier.fillMaxSize()) {
+            OutlinedTextField(
+                value = urlInput,
+                onValueChange = { urlInput = it },
+                modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 4.dp),
+                label = { Text("Search or enter address") },
+                singleLine = true,
+            )
+            Row(Modifier.padding(horizontal = 8.dp)) {
+                TextButton(onClick = { tabManager.activeSession()?.goBack() }) { Text("◀") }
+                TextButton(onClick = { tabManager.activeSession()?.goForward() }) { Text("▶") }
+                TextButton(onClick = { tabManager.activeSession()?.reload() }) { Text("⟳") }
+                TextButton(onClick = { tabManager.activeSession()?.loadUri(normalize(urlInput)) }) { Text("Go") }
+                TextButton(onClick = { tabManager.open("about:blank") }) { Text("+") }
+            }
+
+            // Tab strip
+            LazyRow(Modifier.padding(horizontal = 8.dp)) {
+                items(tabManager.tabs, key = { it.id }) { tab ->
+                    AssistChip(
+                        onClick = { tabManager.activate(tab.id) },
+                        label = {
+                            Text(
+                                "Tab ${tab.id}" + (if (tab.id == activeId) " ●" else ""),
+                                maxLines = 1,
+                            )
+                        },
+                        trailingIcon = {
+                            TextButton(onClick = { tabManager.close(tab.id) }) { Text("✕") }
+                        },
+                        modifier = Modifier.padding(end = 4.dp),
+                    )
+                }
+            }
+
+            // Console output (native layer of the dev console — M4 grows this into a screen)
+            val lines = tabManager.consoleLines.takeLast(3)
+            if (lines.isNotEmpty()) {
+                Surface(
+                    tonalElevation = 2.dp,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .heightIn(max = 72.dp),
+                ) {
+                    Column(Modifier.padding(6.dp)) {
+                        lines.forEach { Text(it, style = MaterialTheme.typography.labelSmall, maxLines = 1) }
+                    }
+                }
+            }
+
+            AndroidView(
+                factory = { geckoView },
+                modifier = Modifier.fillMaxWidth().weight(1f),
+            )
+        }
+    }
+
+    private fun normalize(input: String): String = when {
+        input.startsWith("http://") || input.startsWith("https://") -> input
+        input.startsWith("about:") -> input
+        input.contains(".") && !input.contains(" ") -> "https://$input"
+        else -> "https://duckduckgo.com/?q=" + android.net.Uri.encode(input)
+    }
+}