@lampdotdev/lamp 0.0.0-stage → 0.35.0

package/cli/lamps/android-host/LampPageGateway.kt

@@ -0,0 +1,345 @@
+// Written by Lamp before every build; don't edit. The page's LampAI (Web/lamp.js), answered through this app.
+package {{PACKAGE}}
+
+import android.webkit.WebView
+import androidx.webkit.WebViewCompat
+import androidx.webkit.WebViewFeature
+import java.io.File
+import java.net.InetSocketAddress
+import java.net.Socket
+import org.json.JSONObject
+import kotlin.concurrent.thread
+
+object LampPageGateway {
+    private val routes = setOf("/ai", "/ai/status", "/ai/image", "/ai/decide", "/ai/act", "/ai/hear")
+
+    /** Answers the page at `origin`, the page's own, in its main frame: no other page or frame reaches Lamp. */
+    fun attach(web: WebView, origin: String) {
+        if (!WebViewFeature.isFeatureSupported(WebViewFeature.WEB_MESSAGE_LISTENER)) return
+        val files = web.context.filesDir
+        WebViewCompat.addWebMessageListener(web, "lampGatewayHost", setOf(origin)) { _, message, _, isMainFrame, reply ->
+            val call = try { JSONObject(message.data ?: "") } catch (e: Exception) { null }
+            if (!isMainFrame || call == null) return@addWebMessageListener
+            val id = call.optInt("id")
+            val path = call.optString("path")
+            val body = call.optString("body", "{}")
+            // The page's own wait for an answer (a status check's few seconds, a question's minutes).
+            val timeout = call.optInt("timeout", 240_000).coerceIn(1_000, 240_000)
+            thread {
+                val (status, text) = if (path in routes) post(files, path, body, timeout) else 404 to JSONObject().put("error", "Not found").toString()
+                val answer = JSONObject().put("id", id).put("status", status).put("body", text).toString()
+                web.post { reply.postMessage(answer) }
+            }
+        }
+    }
+
+    private fun failure(message: String) = 503 to JSONObject().put("error", message).toString()
+
+    /** Plain HTTP on the Mac's own network, on a socket, as the Kotlin building blocks speak it: each way to the Mac
+     *  Lamp wrote down in turn, and all of them once more after a moment, in case Lamp is just starting. */
+    private fun post(files: File, path: String, body: String, timeout: Int): Pair<Int, String> {
+        val deadline = System.currentTimeMillis() + timeout
+        val install = try { JSONObject(File(files, "lamp-install.json").readText()) } catch (e: Exception) {
+            return failure("This copy of the app wasn't opened from Lamp, so it can't use AI. Open it from Lamp on your Mac.")
+        }
+        val token = install.optString("token")
+        val list = install.optJSONArray("routes") ?: return failure("Couldn't reach Lamp. Open Lamp on your Mac and try again.")
+        val bytes = body.toByteArray(Charsets.UTF_8)
+        // What the person said is paid for once heard: tried on each way to the Mac once, never again after a moment
+        // (Lamp knows the recording by the id lamp.js gave it, so two ways reaching it still pay once).
+        for (attempt in 0 until (if (path == "/ai/hear") 1 else 2)) {
+            for (i in 0 until list.length()) {
+                val route = list.optJSONObject(i) ?: continue
+                val left = (deadline - System.currentTimeMillis()).toInt()
+                if (left <= 0) break
+                try {
+                    return exchange(route, path, token, bytes, left)
+                } catch (e: Exception) {
+                    continue
+                }
+            }
+            if (attempt == 0 && deadline - System.currentTimeMillis() > 3000) Thread.sleep(3000) else break
+        }
+        return failure(if (install.optBoolean("device")) "Couldn't reach Lamp on your Mac. Keep this device on the same Wi‑Fi as the Mac, with Lamp open, and try again."
+                       else "Couldn't reach Lamp. Open Lamp on your Mac and try again.")
+    }
+
+    private fun exchange(route: JSONObject, path: String, token: String, body: ByteArray, timeout: Int): Pair<Int, String> {
+        Socket().use { socket ->
+            socket.connect(InetSocketAddress(route.getString("address"), route.getInt("port")), minOf(4000, timeout))
+            socket.soTimeout = timeout
+            val head = "POST $path HTTP/1.1\r\nHost: ${route.getString("host")}\r\nAuthorization: Bearer $token\r\n" +
+                "Content-Type: application/json\r\nContent-Length: ${body.size}\r\nConnection: close\r\n\r\n"
+            socket.getOutputStream().apply { write(head.toByteArray()); write(body); flush() }
+            val all = socket.getInputStream().readBytes()
+            val split = (0..all.size - 4).firstOrNull { all[it] == '\r'.code.toByte() && all[it + 1] == '\n'.code.toByte() && all[it + 2] == '\r'.code.toByte() && all[it + 3] == '\n'.code.toByte() }
+                ?: throw java.io.IOException("Lamp's answer was cut short.")
+            val status = String(all, 0, split).split("\r\n").first().split(" ").getOrNull(1)?.toIntOrNull()
+                ?: throw java.io.IOException("Lamp's answer couldn't be read.")
+            return status to String(all, split + 4, all.size - split - 4)
+        }
+    }
+}
+
+/** The page's LampVoice (Web/lamp.js's `lampVoiceHost`): what the person says, recorded by whatever microphone this
+ *  device gives an app (a TV remote's included, which Android hands over as the voice-recognition source), as
+ *  16 kHz mono 16-bit PCM in a WAV for the page to have transcribed (`LampAI.hear`); and what the page says back,
+ *  read out. Asking what's possible never prompts: only `listen` asks for the microphone. One recording at a time,
+ *  each with its own stop (`LampVoiceTake`), tagged with the page's session; a stop keeps it, a cancel throws it
+ *  away, and the app leaving the screen or the page loading again cancels it whether the page says so or not. Every
+ *  answer goes back to the page that asked, and none to a page loaded since. Only the page's own origin, in its
+ *  main frame. */
+object LampPageVoice {
+    private const val RATE = 16000
+    /** One call from the page: answered on its own page's channel, and only while that page is still the one shown. */
+    private class Call(val id: Int, val proxy: androidx.webkit.JavaScriptReplyProxy, val page: Int, val tag: String = "")
+    private var activity: android.app.Activity? = null
+    private var web: WebView? = null
+    @Volatile private var page = 0                       // counts the pages loaded
+    @Volatile private var take: LampVoiceTake? = null    // the recording now
+    private var worker: Thread? = null
+    private var waiting: Call? = null                    // the listen asking for the microphone
+    private var tts: android.speech.tts.TextToSpeech? = null
+    private var ttsReady = false
+    private var speeches = 0                             // a later speak, hush or cancel overtakes an earlier one
+    private var queued: Pair<Call, () -> Unit>? = null   // a speak waiting for the voice to start
+    private val spoken = java.util.concurrent.ConcurrentHashMap<String, Call>()
+
+    fun attach(activity: android.app.Activity, web: WebView, origin: String) {
+        if (!WebViewFeature.isFeatureSupported(WebViewFeature.WEB_MESSAGE_LISTENER)) return
+        this.activity = activity; this.web = web
+        WebViewCompat.addWebMessageListener(web, "lampVoiceHost", setOf(origin)) { _, message, _, isMainFrame, proxy ->
+            val msg = try { JSONObject(message.data ?: "") } catch (e: Exception) { null }
+            if (!isMainFrame || msg == null) return@addWebMessageListener
+            val tag = msg.optString("session")
+            val call = Call(msg.optInt("id"), proxy, page, tag)
+            when (msg.optString("cmd")) {
+                "status" -> answer(call, status())
+                "listen" -> listen(call)
+                "stop" -> { take?.takeIf { it.tag == tag }?.stop("stopped"); answer(call, JSONObject().put("ok", true)) }
+                "cancel" -> {
+                    take?.takeIf { it.tag == tag }?.stop("cancelled")
+                    waiting?.takeIf { it.tag == tag }?.let { waiting = null; answer(it, JSONObject().put("ended", "cancelled")) }
+                    answer(call, JSONObject().put("ok", true))
+                }
+                "speak" -> speak(msg.optString("text"), call)
+                "hush" -> { hush(); answer(call, JSONObject().put("ok", true)) }
+                else -> answer(call, JSONObject().put("error", "Unknown."))
+            }
+        }
+    }
+
+    /** The app left the screen: nothing goes on being heard or said, and a listen waiting for the microphone is
+     *  answered as cancelled. */
+    fun cancel() {
+        waiting?.let { waiting = null; answer(it, JSONObject().put("ended", "cancelled")) }
+        take?.stop("cancelled")
+        hush()
+    }
+
+    /** The page loads again: as leaving the screen, and nothing still under way answers the new page. */
+    fun newPage() { cancel(); page++ }
+
+    private fun hush() {
+        speeches++
+        queued?.let { queued = null; answer(it.first, JSONObject().put("done", false)) }
+        tts?.stop()
+    }
+
+    private fun granted() = activity?.checkSelfPermission(android.Manifest.permission.RECORD_AUDIO) == android.content.pm.PackageManager.PERMISSION_GRANTED
+
+    fun status(): JSONObject {
+        val a = activity
+        val permission = when {
+            granted() -> "granted"
+            a != null && a.shouldShowRequestPermissionRationale(android.Manifest.permission.RECORD_AUDIO) -> "denied"
+            else -> "ask"
+        }
+        val inputs = (a?.getSystemService(android.content.Context.AUDIO_SERVICE) as? android.media.AudioManager)
+            ?.getDevices(android.media.AudioManager.GET_DEVICES_INPUTS)?.size ?: 0
+        return JSONObject().put("listen", inputs > 0).put("speak", true).put("permission", permission)
+            .put("why", if (inputs > 0) "" else "This device has no microphone.").put("maxSeconds", LampVoiceEnd.MAX)
+    }
+
+    private fun listen(call: Call) {
+        cancel()
+        if (!granted()) {
+            waiting = call
+            activity?.requestPermissions(arrayOf(android.Manifest.permission.RECORD_AUDIO), 7307)
+            return
+        }
+        record(call)
+    }
+
+    /** The person's answer to the system's question (MainActivity passes it on). Closed meanwhile: nothing starts. */
+    fun permissionResult(code: Int, allowed: Boolean) {
+        if (code != 7307) return
+        val call = waiting ?: return
+        waiting = null
+        if (call.page != page) return
+        if (!allowed) { answer(call, JSONObject().put("ended", "denied")); return }
+        record(call)
+    }
+
+    private fun record(call: Call) {
+        val mine = LampVoiceTake(call.tag)
+        val before = worker
+        take = mine
+        worker = thread {
+            // The recording before lets the microphone go first (it ends within a frame of being cancelled).
+            before?.join(2000)
+            val result = try { capture(mine, call) } catch (e: Exception) { JSONObject().put("ended", "error").put("error", e.message ?: "The microphone failed.") }
+            web?.post { if (take === mine) take = null }
+            answer(call, result)
+        }
+    }
+
+    /** Records until the person stops speaking, a stop, a cancel or the limit; levels go to the page as it goes. */
+    private fun capture(mine: LampVoiceTake, call: Call): JSONObject {
+        mine.stopAs?.let { return JSONObject().put("ended", it) }
+        val min = android.media.AudioRecord.getMinBufferSize(RATE, android.media.AudioFormat.CHANNEL_IN_MONO, android.media.AudioFormat.ENCODING_PCM_16BIT)
+        @Suppress("MissingPermission")
+        val rec = android.media.AudioRecord(android.media.MediaRecorder.AudioSource.VOICE_RECOGNITION, RATE,
+            android.media.AudioFormat.CHANNEL_IN_MONO, android.media.AudioFormat.ENCODING_PCM_16BIT, maxOf(min, RATE))
+        try {
+            if (rec.state != android.media.AudioRecord.STATE_INITIALIZED) return JSONObject().put("ended", "error").put("error", "The microphone didn't open.")
+            rec.startRecording()
+            if (rec.recordingState != android.media.AudioRecord.RECORDSTATE_RECORDING) return JSONObject().put("ended", "error").put("error", "The microphone didn't start.")
+            val routed = rec.routedDevice?.type ?: -1
+            // Never waits for audio: the clock ends it on time, and a cancel within a frame, even when nothing comes.
+            val ended = mine.run({ buf, from -> rec.read(buf, from, buf.size - from, android.media.AudioRecord.READ_NON_BLOCKING) }, System::nanoTime) { level, speech ->
+                event(call, JSONObject().put("event", "level").put("session", mine.tag).put("level", minOf(1.0, level * 4)).put("speech", speech))
+            }
+            val audio = mine.pcm.toByteArray()
+            // The microphone stopped sending mid-way: what it heard may be cut off, so it's an error, not something to act on.
+            if (ended == "lost") return JSONObject().put("ended", "error").put("error", "The microphone stopped sending sound. Try again.")
+                .put("peak", mine.end.peak).put("speech", mine.end.speechAt >= 0).put("input", routed)
+            val out = JSONObject().put("ended", ended).put("seconds", audio.size / 2.0 / RATE).put("peak", mine.end.peak)
+                .put("speech", mine.end.speechAt >= 0).put("input", routed)
+            if (ended == "stopped" || ended == "quiet" || ended == "cap") out.put("audio", android.util.Base64.encodeToString(wav(audio), android.util.Base64.NO_WRAP))
+            return out
+        } finally {
+            try { rec.stop() } catch (e: Exception) {}
+            rec.release()
+        }
+    }
+
+    private fun wav(pcm: ByteArray): ByteArray {
+        val h = java.nio.ByteBuffer.allocate(44).order(java.nio.ByteOrder.LITTLE_ENDIAN)
+        h.put("RIFF".toByteArray()).putInt(36 + pcm.size).put("WAVE".toByteArray()).put("fmt ".toByteArray()).putInt(16).putShort(1).putShort(1)
+            .putInt(RATE).putInt(RATE * 2).putShort(2).putShort(16).put("data".toByteArray()).putInt(pcm.size)
+        return h.array() + pcm
+    }
+
+    /** Reads the words out; resolves once they're said to the end, or false when they couldn't be or were cut off. */
+    private fun speak(text: String, call: Call) {
+        val a = activity ?: return answer(call, JSONObject().put("done", false))
+        if (text.isEmpty() || take != null) return answer(call, JSONObject().put("done", false))
+        hush()
+        val asked = speeches
+        val say = {
+            val u = "u${call.page}-${call.id}"
+            if (asked != speeches || call.page != page) answer(call, JSONObject().put("done", false))
+            else {
+                spoken[u] = call
+                if (tts?.speak(text, android.speech.tts.TextToSpeech.QUEUE_FLUSH, null, u) != android.speech.tts.TextToSpeech.SUCCESS)
+                    spoken.remove(u)?.let { answer(it, JSONObject().put("done", false)) }
+            }
+        }
+        if (tts != null && ttsReady) return say()
+        queued = call to say
+        if (tts != null) return                           // already starting: it says the latest when it's ready
+        tts = android.speech.tts.TextToSpeech(a) { status ->
+            web?.post {
+                ttsReady = status == android.speech.tts.TextToSpeech.SUCCESS
+                if (ttsReady) tts?.setOnUtteranceProgressListener(object : android.speech.tts.UtteranceProgressListener() {
+                    override fun onStart(u: String) {}
+                    override fun onDone(u: String) { spoken.remove(u)?.let { answer(it, JSONObject().put("done", true)) } }
+                    @Deprecated("Deprecated in Java") override fun onError(u: String) { spoken.remove(u)?.let { answer(it, JSONObject().put("done", false)) } }
+                    override fun onStop(u: String, interrupted: Boolean) { spoken.remove(u)?.let { answer(it, JSONObject().put("done", false)) } }
+                }) else { tts?.shutdown(); tts = null }
+                val next = queued; queued = null
+                if (next != null) { if (ttsReady) next.second() else answer(next.first, JSONObject().put("done", false)) }
+            }
+        }
+    }
+
+    private fun answer(call: Call, body: JSONObject) = post(call, body.put("id", call.id))
+    private fun event(call: Call, body: JSONObject) = post(call, body)
+    private fun post(call: Call, body: JSONObject) {
+        val w = web ?: return
+        w.post { if (call.page == page) try { call.proxy.postMessage(body.toString()) } catch (e: Exception) {} }
+    }
+}
+
+/** When one recording ends, from its levels and the clock alone (the same rule as LampVoiceEnd in LampPage.swift).
+ *  Speech is a level three times the room's, and above a floor. The room is the quietest it has been lately: it
+ *  follows a dip at once and, until speech is heard, rises back over a couple of seconds, so speech from the very
+ *  first moment counts once its first pause shows the room; once speech is heard the room stays put, so talking on
+ *  without a pause is never taken for the room. A recording ends as finished (`quiet`) only after 1.2 s of quiet
+ *  that was received: audio under the speech level after speech, or under the floor (past 6 s) when there was only
+ *  sound. Missing audio is never quiet: a stream that stops coming for a second ends as `lost`, which nothing acts
+ *  on. With no sound at all by 6 s it's `nothing`. Anything still going at 15 s is `cap`, which is never acted on.
+ *  Asked every frame whether audio comes or not, so these hold when audio stops. A rule of thumb on levels, not a
+ *  way of telling speech from a television. */
+class LampVoiceEnd {
+    companion object { const val MAX = 15.0; const val WAIT = 6.0; const val QUIET = 1.2; const val FLOOR = 0.02; const val RISE = 2.0; const val STALL = 1.0 }
+    var speechAt = -1.0; private set
+    var peak = 0.0; private set
+    private var room = -1.0; private var at = 0.0; private var lastHeard = -1.0; private var sound = false
+    // When the quiet that's going on now began, by the audio received: under the speech level, and under the floor.
+    private var quietFrom = -1.0; private var silentFrom = -1.0
+    @Synchronized fun heard(level: Double, top: Double, t: Double) {
+        peak = maxOf(peak, top)
+        if (room < 0 || level < room) room = level
+        else if (speechAt < 0) room += (level - room) * minOf(1.0, (t - at) / RISE)
+        at = t
+        lastHeard = t
+        if (level > FLOOR) { sound = true; silentFrom = -1.0 } else if (silentFrom < 0) silentFrom = t
+        if (level > maxOf(room * 3, FLOOR)) { if (speechAt < 0) speechAt = t; quietFrom = -1.0 }
+        else if (quietFrom < 0) quietFrom = t
+    }
+    @Synchronized fun ended(t: Double): String? = when {
+        t >= MAX -> "cap"
+        lastHeard < 0 -> if (t >= WAIT) "nothing" else null
+        speechAt >= 0 && quietFrom >= 0 && lastHeard - quietFrom >= QUIET -> "quiet"
+        speechAt < 0 && sound && t >= WAIT && silentFrom >= 0 && lastHeard - silentFrom >= QUIET -> "quiet"
+        speechAt < 0 && !sound && t >= WAIT -> "nothing"
+        // Audio that has stopped coming isn't quiet: what was heard may have been cut off.
+        t - lastHeard >= STALL -> "lost"
+        else -> null
+    }
+}
+
+/** One recording, with its own stop: a stop or cancel meant for one never reaches another. `run` reads 40 ms
+ *  frames from `read` (what's there, without waiting: 0 when nothing has come) until a stop, a cancel or
+ *  LampVoiceEnd says it's over, checking both between every read. */
+class LampVoiceTake(val tag: String) {
+    @Volatile var stopAs: String? = null; private set
+    val end = LampVoiceEnd()
+    val pcm = java.io.ByteArrayOutputStream()
+    fun stop(how: String) { if (stopAs == null) stopAs = how }
+    fun run(read: (ShortArray, Int) -> Int, now: () -> Long, level: (Double, Boolean) -> Unit): String {
+        val started = now()
+        val frame = ShortArray(640)
+        var filled = 0
+        while (true) {
+            stopAs?.let { return it }
+            end.ended((now() - started) / 1e9)?.let { return it }
+            val n = read(frame, filled)
+            if (n < 0) throw java.io.IOException("The microphone stopped working ($n).")
+            if (n == 0) { Thread.sleep(10); continue }
+            filled += n
+            if (filled < frame.size) continue
+            filled = 0
+            var sum = 0.0; var top = 0.0
+            for (v in frame) {
+                val x = v / 32768.0; sum += x * x; top = maxOf(top, kotlin.math.abs(x))
+                pcm.write(v.toInt() and 0xff); pcm.write((v.toInt() shr 8) and 0xff)
+            }
+            val l = kotlin.math.sqrt(sum / frame.size)
+            end.heard(l, top, (now() - started) / 1e9)
+            level(l, end.speechAt >= 0)
+        }
+    }
+}

package/cli/lamps/android-host/app/build.gradle.kts

@@ -0,0 +1,40 @@
+// Written by Lamp before every build; don't edit.
+plugins {
+    alias(libs.plugins.android.application)
+}
+
+android {
+    namespace = "{{ANDROID_PACKAGE}}"
+    compileSdk = 36
+    defaultConfig {
+        applicationId = "{{ANDROID_PACKAGE}}"
+        minSdk = 26
+        targetSdk = 36
+        versionCode = 1
+        versionName = "1.0"
+    }
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+    buildFeatures { buildConfig = false }
+    sourceSets["main"].kotlin.srcDirs("src/main/kotlin")
+    // The page and the icon, which build.sh puts in the game's build/ before Gradle runs.
+    sourceSets["main"].assets.srcDirs("../../../build/android-assets")
+    sourceSets["main"].res.srcDirs("../../../build/android-res")
+    // The page's files are served as they are: a compressed asset can't be streamed to the WebView. And every
+    // folder of the page's goes in: Android's own list of what an app's assets leave out drops any folder whose
+    // name starts with an underscore, which is where a built site keeps its scripts (_next, _astro).
+    androidResources {
+        noCompress += listOf("js", "html", "css", "json", "glb", "gltf", "bin", "png", "jpg", "wav", "ogg", "mp3", "m4a")
+        ignoreAssetsPattern = "!.svn:!.git:!.ds_store:!*.scc:.*:!CVS:!thumbs.db:!picasa.ini:!*~"
+    }
+}
+
+kotlin {
+    jvmToolchain(17)
+}
+
+dependencies {
+    implementation(libs.androidx.webkit)
+}

package/cli/lamps/android-host/build.gradle.kts

@@ -0,0 +1,4 @@
+// Written by Lamp before every build; don't edit.
+plugins {
+    alias(libs.plugins.android.application) apply false
+}

package/cli/lamps/android-host/game/AndroidManifest.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Written by Lamp before every build; don't edit. -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- Back reaches the page as a key (the game's B, a TV page's Back), not Android's predictive back, which would
+         leave the app before the page says what going back means. -->
+    <!-- One app for phones and TVs: no touch screen needed, and on a TV's home screen through the leanback launcher. -->
+    <uses-feature android:name="android.hardware.touchscreen" android:required="false" />
+    <uses-feature android:name="android.hardware.gamepad" android:required="false" />
+    <uses-feature android:name="android.software.leanback" android:required="false" />
+    <!-- A page may read the web (a screen's weather, a game's scores), as it does in every other place. -->
+    <uses-permission android:name="android.permission.INTERNET" />
+    <application
+        android:allowBackup="true"
+        android:banner="@drawable/lamp_banner"
+        android:enableOnBackInvokedCallback="false"
+        android:icon="@mipmap/ic_launcher"
+        android:label="{{NAME}}"
+        android:hardwareAccelerated="true"
+        android:isGame="true"
+        android:theme="@android:style/Theme.Black.NoTitleBar.Fullscreen">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:screenOrientation="sensorLandscape"
+            android:configChanges="orientation|screenSize|screenLayout|keyboard|keyboardHidden|navigation|uiMode">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+                <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>

package/cli/lamps/android-host/game/MainActivity.kt

@@ -0,0 +1,173 @@
+// Written by Lamp before every build; don't edit. The game is the page in Web/.
+package {{PACKAGE}}
+
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.hardware.input.InputManager
+import android.os.Bundle
+import android.util.Log
+import android.view.InputDevice
+import android.view.KeyEvent
+import android.view.MotionEvent
+import android.view.View
+import android.view.WindowInsets
+import android.view.WindowInsetsController
+import android.webkit.ConsoleMessage
+import android.webkit.WebChromeClient
+import android.webkit.WebResourceRequest
+import android.webkit.WebResourceResponse
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import kotlin.math.abs
+
+class MainActivity : Activity(), InputManager.InputDeviceListener {
+    private lateinit var web: WebView
+    // The first controller, as the page's pad 0 is: sticks -1 to 1 (up positive), triggers 0 to 1, buttons as Lamp's bits.
+    private var lx = 0f; private var ly = 0f; private var rx = 0f; private var ry = 0f; private var lt = 0f; private var rt = 0f
+    private var down = 0
+    // The controller's USB vendor, so the page names its buttons as they're marked (a PlayStation's shapes).
+    private var vendor = 0
+    private var sent = ""
+
+    @SuppressLint("SetJavaScriptEnabled")
+    override fun onCreate(saved: Bundle?) {
+        super.onCreate(saved)
+        web = WebView(this)
+        web.setBackgroundColor(0xFF000000.toInt())
+        web.settings.javaScriptEnabled = true
+        web.settings.domStorageEnabled = true
+        web.settings.mediaPlaybackRequiresUserGesture = false
+        web.settings.allowFileAccess = false
+        web.webViewClient = object : WebViewClient() {
+            // The page's files, from the app's own assets, at an address of the game's own.
+            override fun shouldInterceptRequest(view: WebView, request: WebResourceRequest): WebResourceResponse? {
+                val url = request.url
+                if (url.host != HOST) return null
+                val path = (url.path ?: "/").trimStart('/').ifEmpty { "index.html" }
+                if (path.split('/').any { it == ".." }) return notFound()
+                return try {
+                    WebResourceResponse(type(path), "utf-8", assets.open("Web/$path"))
+                } catch (e: Exception) { notFound() }
+            }
+            override fun shouldOverrideUrlLoading(view: WebView, request: WebResourceRequest) = request.url.host != HOST
+        }
+        web.webChromeClient = object : WebChromeClient() {
+            override fun onConsoleMessage(message: ConsoleMessage): Boolean {
+                Log.i("Lamp", message.message())
+                return true
+            }
+        }
+        setContentView(web)
+        LampPageGateway.attach(web, "https://$HOST")
+        (getSystemService(INPUT_SERVICE) as InputManager).registerInputDeviceListener(this, null)
+        immerse()
+        web.loadUrl("https://$HOST/index.html")
+    }
+
+    override fun onWindowFocusChanged(focused: Boolean) {
+        super.onWindowFocusChanged(focused)
+        if (focused) immerse()
+    }
+
+    private fun immerse() {
+        if (android.os.Build.VERSION.SDK_INT >= 30) {
+            window.insetsController?.let {
+                it.hide(WindowInsets.Type.systemBars())
+                it.systemBarsBehavior = WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+            }
+        } else {
+            @Suppress("DEPRECATION")
+            window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY or View.SYSTEM_UI_FLAG_FULLSCREEN or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+        }
+    }
+
+    override fun onPause() {
+        super.onPause()
+        web.onPause()
+    }
+
+    // A controller that goes away mid-press leaves nothing held: the page sees it let go, and its touch controls
+    // can come back.
+    override fun onInputDeviceRemoved(id: Int) {
+        lx = 0f; ly = 0f; rx = 0f; ry = 0f; lt = 0f; rt = 0f; down = 0
+        send()
+    }
+    override fun onInputDeviceAdded(id: Int) {}
+    override fun onInputDeviceChanged(id: Int) {}
+    override fun onDestroy() {
+        (getSystemService(INPUT_SERVICE) as InputManager).unregisterInputDeviceListener(this)
+        super.onDestroy()
+    }
+    override fun onResume() { super.onResume(); web.onResume() }
+
+    // MARK: The controller
+
+    private fun bit(code: Int): Int = when (code) {
+        KeyEvent.KEYCODE_BUTTON_A -> 1; KeyEvent.KEYCODE_BUTTON_B -> 2; KeyEvent.KEYCODE_BUTTON_X -> 4; KeyEvent.KEYCODE_BUTTON_Y -> 8
+        KeyEvent.KEYCODE_BUTTON_L1 -> 16; KeyEvent.KEYCODE_BUTTON_R1 -> 32
+        KeyEvent.KEYCODE_BUTTON_START, KeyEvent.KEYCODE_MENU -> 64; KeyEvent.KEYCODE_BUTTON_SELECT -> 128
+        KeyEvent.KEYCODE_DPAD_UP -> 256; KeyEvent.KEYCODE_DPAD_DOWN -> 512; KeyEvent.KEYCODE_DPAD_LEFT -> 1024; KeyEvent.KEYCODE_DPAD_RIGHT -> 2048
+        KeyEvent.KEYCODE_BUTTON_THUMBL -> 4096; KeyEvent.KEYCODE_BUTTON_THUMBR -> 8192
+        else -> 0
+    }
+
+    // A TV remote's d-pad is a controller's to a game: its arrows the d-pad, OK the A button, play/pause Start.
+    private fun fromController(event: KeyEvent) =
+        event.isFromSource(InputDevice.SOURCE_GAMEPAD) || event.isFromSource(InputDevice.SOURCE_JOYSTICK) || KeyEvent.isGamepadButton(event.keyCode)
+            || event.isFromSource(InputDevice.SOURCE_DPAD) || event.keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE
+    private fun remote(code: Int) = when (code) {
+        KeyEvent.KEYCODE_DPAD_CENTER -> KeyEvent.KEYCODE_BUTTON_A; KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE -> KeyEvent.KEYCODE_BUTTON_START; else -> code
+    }
+
+
+    override fun dispatchKeyEvent(event: KeyEvent): Boolean {
+        // Back is the game's B, as on a console: the game says what going back means, and stays open.
+        val code = if (event.keyCode == KeyEvent.KEYCODE_BACK) KeyEvent.KEYCODE_BUTTON_B else remote(event.keyCode)
+        val b = bit(code)
+        if (b != 0 && (fromController(event) || event.keyCode == KeyEvent.KEYCODE_BACK)) {
+            if (fromController(event)) vendor = event.device?.vendorId ?: 0
+            down = if (event.action == KeyEvent.ACTION_DOWN) down or b else down and b.inv()
+            send()
+            return true
+        }
+        return super.dispatchKeyEvent(event)
+    }
+
+    private fun dead(v: Float) = if (abs(v) < 0.15f) 0f else (v - Math.signum(v) * 0.15f) / 0.85f
+
+    override fun dispatchGenericMotionEvent(event: MotionEvent): Boolean {
+        if (!event.isFromSource(InputDevice.SOURCE_JOYSTICK) || event.action != MotionEvent.ACTION_MOVE) return super.dispatchGenericMotionEvent(event)
+        vendor = event.device?.vendorId ?: 0
+        lx = dead(event.getAxisValue(MotionEvent.AXIS_X)); ly = -dead(event.getAxisValue(MotionEvent.AXIS_Y))
+        rx = dead(event.getAxisValue(MotionEvent.AXIS_Z)); ry = -dead(event.getAxisValue(MotionEvent.AXIS_RZ))
+        lt = maxOf(event.getAxisValue(MotionEvent.AXIS_LTRIGGER), event.getAxisValue(MotionEvent.AXIS_BRAKE))
+        rt = maxOf(event.getAxisValue(MotionEvent.AXIS_RTRIGGER), event.getAxisValue(MotionEvent.AXIS_GAS))
+        // A d-pad that reports as a hat.
+        val hx = event.getAxisValue(MotionEvent.AXIS_HAT_X); val hy = event.getAxisValue(MotionEvent.AXIS_HAT_Y)
+        down = down and (256 or 512 or 1024 or 2048).inv() or
+            (if (hy < -0.5f) 256 else 0) or (if (hy > 0.5f) 512 else 0) or (if (hx < -0.5f) 1024 else 0) or (if (hx > 0.5f) 2048 else 0)
+        send()
+        return true
+    }
+
+    private fun send() {
+        val now = "$lx,$ly,$rx,$ry,$lt,$rt,$down,$vendor"
+        if (now == sent) return
+        sent = now
+        web.evaluateJavascript("window.lampNativePad&&lampNativePad($now)", null)
+    }
+
+    private fun type(path: String) = when (path.substringAfterLast('.', "").lowercase()) {
+        "html", "htm" -> "text/html"; "js", "mjs" -> "text/javascript"; "css" -> "text/css"; "json" -> "application/json"
+        "png" -> "image/png"; "jpg", "jpeg" -> "image/jpeg"; "webp" -> "image/webp"; "svg" -> "image/svg+xml"
+        "glb" -> "model/gltf-binary"; "gltf" -> "model/gltf+json"; "wav" -> "audio/wav"; "ogg" -> "audio/ogg"
+        "mp3" -> "audio/mpeg"; "m4a" -> "audio/mp4"; "wasm" -> "application/wasm"
+        else -> "application/octet-stream"
+    }
+
+    private fun notFound() = WebResourceResponse("text/plain", "utf-8", 404, "Not Found", emptyMap(), "".byteInputStream())
+
+    companion object {
+        const val HOST = "lamp.game"
+    }
+}

package/cli/lamps/android-host/gradle/libs.versions.toml

@@ -0,0 +1,39 @@
+# Written by Lamp before every build; don't edit. Add other libraries in app/build.gradle.kts with their full names.
+[versions]
+androidGradlePlugin = "9.0.1"
+androidxCore = "1.18.0"
+androidxLifecycle = "2.10.0"
+androidxActivity = "1.13.0"
+androidxComposeBom = "2026.03.01"
+androidxNavigation3 = "1.0.1"
+androidxDatastore = "1.1.7"
+androidxWebkit = "1.14.0"
+androidxTvMaterial = "1.1.0"
+coroutines = "1.10.2"
+kotlin = "2.3.20"
+serialization = "1.9.0"
+
+[libraries]
+androidx-core-ktx = { module = "androidx.core:core-ktx", version.ref = "androidxCore" }
+androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "androidxActivity" }
+androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "androidxComposeBom" }
+androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
+androidx-compose-material-icons = { group = "androidx.compose.material", name = "material-icons-extended" }
+androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" }
+androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
+androidx-compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
+androidx-lifecycle-viewmodel-compose = { module = "androidx.lifecycle:lifecycle-viewmodel-compose", version.ref = "androidxLifecycle" }
+androidx-lifecycle-runtime-compose = { module = "androidx.lifecycle:lifecycle-runtime-compose", version.ref = "androidxLifecycle" }
+androidx-lifecycle-runtime-ktx = { module = "androidx.lifecycle:lifecycle-runtime-ktx", version.ref = "androidxLifecycle" }
+androidx-navigation3-runtime = { module = "androidx.navigation3:navigation3-runtime", version.ref = "androidxNavigation3" }
+androidx-navigation3-ui = { module = "androidx.navigation3:navigation3-ui", version.ref = "androidxNavigation3" }
+androidx-datastore-preferences = { module = "androidx.datastore:datastore-preferences", version.ref = "androidxDatastore" }
+kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "coroutines" }
+kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "serialization" }
+androidx-webkit = { module = "androidx.webkit:webkit", version.ref = "androidxWebkit" }
+androidx-tv-material = { module = "androidx.tv:tv-material", version.ref = "androidxTvMaterial" }
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "androidGradlePlugin" }
+compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }

package/cli/lamps/android-host/gradle.properties

@@ -0,0 +1,8 @@
+# Written by Lamp before every build; don't edit.
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 -Dlamp.app={{SLUG}}
+org.gradle.daemon.idletimeout=600000
+org.gradle.caching=true
+org.gradle.configuration-cache=true
+android.useAndroidX=true
+kotlin.code.style=official
+android.nonTransitiveRClass=true