android/: the Android sample app (model picker, hold to talk, three clips, device check); card: the Sample app line with the Galaxy S26 numbers

.gitattributes

@@ -36,3 +36,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 Qwen3-ASR-1.7B.litertlm filter=lfs diff=lfs merge=lfs -text
 assets/demo_s26.png filter=lfs diff=lfs merge=lfs -text
 assets/demo_s26.mp4 filter=lfs diff=lfs merge=lfs -text
+android/app/src/main/res/raw/fleurs_cmn_1698.wav filter=lfs diff=lfs merge=lfs -text
+android/app/src/main/res/raw/fleurs_en_1698.wav filter=lfs diff=lfs merge=lfs -text
+android/app/src/main/res/raw/fleurs_ja_1698.wav filter=lfs diff=lfs merge=lfs -text

README.md

@@ -153,6 +153,8 @@ print(raw.partition("<asr_text>")[2].strip())
 
 For the Chinese example clip `raw` is `language Chinese<asr_text>开放时间：早上九点至下午五点。` and the script prints the text after the tag. `backend=GPU()` (from `litert_lm.interfaces`) puts the language model on the GPU. Keep `audio_backend=CPU()`: the audio encoder does not run on the GPU delegate (`create_conversation` fails). The Kotlin Conversation API takes the same calls. In the Galaxy S26 app above (`litertlm-android` 0.17.1, CPU), the three clips gave the same answers, rendered prompts and token counts as the Python API on the Mac (0.17.1, CPU) in all 5 app runs. The Swift API was not run for this file.
 
+Sample app (Android): [`android/`](https://huggingface.co/litert-community/Qwen3-ASR-1.7B/tree/main/android) — one app for this file and two sibling bundles (Qwen3-ASR-1.7B, Fun-ASR-Nano-2512, Confucius4-R2T2): a model picker, hold-to-talk up to 30 s and three FLEURS clips, with a device check. Galaxy S26, language model and audio encoder on the CPU (4 threads), the 6.4 s English clip in 2.49 s and the 9.7 s Mandarin clip in 2.38 s (2026-10-09, CPU at 3.51 / 4.19 GHz); a 9 s microphone recording in 2.97 s with no character error, measured by the app's device check on 2026-10-09.
+
 On Android the S26 rows above came from the command-line tool: `litert_lm_advanced_main --backend=cpu --audio_backend=cpu --sampler_backend=cpu --num_cpu_threads=4 --model_path=Qwen3-ASR-1.7B.litertlm --cache_dir=cache --max_num_tokens=1024 --max_output_tokens=256 --benchmark --input_prompt='[audio:/path/clip.wav]'`.
 
 ## License

android/.gitignore

@@ -0,0 +1,10 @@
+.gradle/
+.kotlin/
+build/
+app/build/
+local.properties
+.gradle-user-home/
+# The .litertlm bundles are pushed to the phone (see README), never committed.
+*.litertlm
+# hf download --local-dir in the README writes the bundles (and its own metadata) here.
+bundles/

android/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daisuke Majima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

android/README.md

@@ -0,0 +1,189 @@
+# ASR LiteRT-LM — speech to text on Android with three LiteRT-LM bundles
+
+Hold the button, speak for up to 30 s, and the app writes what you said. On the CPU of a Galaxy S26
+(4 threads, measured 2026-10-09), Qwen3-ASR-1.7B turned a 6.4 s English clip into text in 2.49 s and
+Fun-ASR-Nano-2512 in 1.19 s. The app runs three speech recognition models in the LiteRT-LM `.litertlm`
+format through one code path: pick a model, then talk or play one of three bundled clips. Everything
+runs on the phone; the app asks for the microphone and nothing else (no network permission).
+
+## Models
+
+| Model | Hugging Face | File | Size | License | Languages |
+|---|---|---|---|---|---|
+| Qwen3-ASR-1.7B | [litert-community/Qwen3-ASR-1.7B](https://huggingface.co/litert-community/Qwen3-ASR-1.7B) | `Qwen3-ASR-1.7B.litertlm` | 2,693,064,192 B | Apache-2.0 | 30 languages (the card scores English, Mandarin, Japanese) |
+| Fun-ASR-Nano-2512 | [litert-community/Fun-ASR-Nano-2512](https://huggingface.co/litert-community/Fun-ASR-Nano-2512) | `Fun-ASR-Nano-2512.litertlm` | 1,255,894,736 B | Apache-2.0 | Chinese, English, Japanese |
+| Confucius4-R2T2 | [mlboydaisuke/Confucius4-R2T2-LiteRT](https://huggingface.co/mlboydaisuke/Confucius4-R2T2-LiteRT) | `Confucius4-R2T2.litertlm` | 2,693,064,192 B | [NetEase Youdao Model Use License Agreement](https://huggingface.co/mlboydaisuke/Confucius4-R2T2-LiteRT/blob/main/MODEL_LICENSE) | Chinese, English; a fine-tune of Qwen3-ASR-1.7B |
+
+Each file holds the audio encoder, the language model, the tokenizer and the prompt template. Read
+the Confucius4-R2T2 agreement before you use that file: it has user-count and revenue thresholds
+(clause 2.2) and limits on using the model to improve other models (clause 3.4).
+
+## Run it in 5 lines
+
+From this directory, with the phone connected over adb:
+
+```bash
+hf download litert-community/Qwen3-ASR-1.7B Qwen3-ASR-1.7B.litertlm --local-dir bundles
+hf download litert-community/Fun-ASR-Nano-2512 Fun-ASR-Nano-2512.litertlm --local-dir bundles
+hf download mlboydaisuke/Confucius4-R2T2-LiteRT Confucius4-R2T2.litertlm --local-dir bundles
+./gradlew :app:installDebug && adb shell am start -n com.asrlitertlm/.MainActivity
+adb push bundles/*.litertlm /sdcard/Android/data/com.asrlitertlm/files/
+```
+
+Reopen the app, tap a model in the picker and hold **Hold to talk**. The first launch creates the
+folder the push writes to. One bundle is enough; the picker marks the others `missing`.
+
+- Storage: the three files take 6.6 GB. The first load of each file writes a runtime cache into the
+  app's cache directory: 3.0 GB for each Qwen3-ASR file, 1.5 GB for Fun-ASR.
+- Run `adb shell touch /sdcard/Android/data/com.asrlitertlm/files/*.litertlm` after the push. adb push
+  writes whole-second modification times, and with those a later launch can miss the runtime cache
+  and write it again ([LiteRT-LM #3772](https://github.com/google-ai-edge/LiteRT-LM/issues/3772)).
+
+## Galaxy S26 numbers
+
+Galaxy S26 (SM-S942Q, Android 16), `litertlm-android` 0.17.1, language model and audio encoder on the
+CPU with 4 threads, 2026-10-09. "Transcribe" is the wall time of `sendMessage()`, from sending the
+clip to the full answer; RTF is that time over the clip's length. The three clips are the same sentence
+in three languages (below).
+
+| Model | zh, 9.7 s | en, 6.4 s | ja, 11.0 s | Microphone, 9 s | CPU limit at the start (big / prime cores) |
+|---|---|---|---|---|---|
+| Qwen3-ASR-1.7B | 2.38 s, RTF 0.25 | 2.49 s, RTF 0.39 | 3.56 s, RTF 0.32 | 2.97 s, CER 0 | 3.51 / 4.19 GHz |
+| Confucius4-R2T2 | 3.48 s, RTF 0.36 | 2.59 s, RTF 0.40 | 3.54 s, RTF 0.32 | 3.17 s, CER 0 | 3.63 / 4.74 GHz (no limit) |
+| Fun-ASR-Nano-2512 | 1.95 s, RTF 0.20 | 1.19 s, RTF 0.19 | 1.83 s, RTF 0.17 | 1.44 s, CER 0 | 3.63 / 4.74 GHz (no limit) |
+
+| Model | Engine load, first (writes the cache) | Engine load, cache in place | Runtime cache | Peak resident memory, first load |
+|---|---|---|---|---|
+| Qwen3-ASR-1.7B | 7.35 s | 0.72 s | 3.0 GB | 5.6 GB |
+| Confucius4-R2T2 | 4.27 s | 1.33 s | 3.0 GB | 5.7 GB |
+| Fun-ASR-Nano-2512 | 1.39 s | 1.13 s | 1.5 GB | 3.5 GB |
+
+- Every clip's text equals the Mac CPU answer of the same file (LiteRT-LM 0.17.1, Python) after
+  removing punctuation and spaces. The three models write the same sentences for these clips.
+- The last column is the CPU limit at the start of the run (the maximum is 3.63 / 4.74 GHz; a warm phone
+  lowers it). The Confucius4-R2T2 and Fun-ASR rows are a second run of the check on the same day with no
+  limit (Confucius4-R2T2 at thermal status 0, Fun-ASR at status 1, each file pushed alone). The first run,
+  with the limit lowered by heat, gave Confucius4-R2T2 4.03 / 3.06 / 3.83 s at 2.75 / 2.67 GHz and
+  Fun-ASR 1.26 / 1.60 / 2.29 s at 2.23 / 2.23 GHz. Confucius4-R2T2 has the same architecture and file
+  size as Qwen3-ASR-1.7B. In a run that started at the maximum, Qwen3-ASR-1.7B took 2.13 / 2.14 / 3.19 s
+  for the three clips.
+- "Engine load" is `Engine.initialize()` plus the first conversation, which creates the audio encoder.
+  The Qwen3-ASR-1.7B cached load is a new launch; the other two are a second load in the same process.
+- Microphone: the phone plays clip en through its speaker and records it with its microphone
+  (media volume 3 of 15), then transcribes the recording. CER is the character error rate against
+  the clip's sentence.
+- Language model on the GPU (launch extra `--es backend gpu`), Fun-ASR-Nano-2512: 1.69 / 1.68 / 2.29 s,
+  the same text. All nodes of the prefill and decode graphs ran on the GPU (LITERT_CL); the audio
+  encoder stays on the CPU (the model cards: the GPU delegate does not take it). Engine load 2.61 s.
+  It was not faster than the CPU here.
+
+## How the app calls a model
+
+The three bundles share one path ([`AsrEngine.kt`](app/src/main/kotlin/com/asrlitertlm/AsrEngine.kt)):
+one `Engine`, a new `Conversation` per clip, and one user message that holds only the audio file. Each
+bundle's template adds the rest: Fun-ASR's default instruction `语音转写：`, Qwen3-ASR's audio markers.
+
+```kotlin
+val engine = Engine(EngineConfig(
+    modelPath = bundle.path,                      // /sdcard/Android/data/com.asrlitertlm/files/<file>
+    backend = Backend.CPU(threadCount = 4),       // the language model
+    audioBackend = Backend.CPU(threadCount = 4),  // the audio encoder
+    cacheDir = context.cacheDir.path,
+))
+engine.initialize()
+
+val raw = engine.createConversation(ConversationConfig(
+    samplerConfig = SamplerConfig(topK = 1, topP = 1.0, temperature = 0.0),
+    maxOutputToken = 512,
+)).use { conversation ->
+    conversation.sendMessage(Message.user(Contents.of(Content.AudioFile(wav.absolutePath)))).toString()
+}
+// Qwen3-ASR-1.7B and Confucius4-R2T2: "language English<asr_text>Everything in the universe ..."
+// Fun-ASR-Nano-2512: "Everything in the universe ..."
+```
+
+Only the answer differs: [`ModelProfile.kt`](app/src/main/kotlin/com/asrlitertlm/ModelProfile.kt)
+splits the Qwen3-ASR answer at `<asr_text>` and shows the named language; Fun-ASR's answer is the text.
+
+- One file is loaded at a time: picking another model closes the engine first. A first load of a
+  Qwen3-ASR file peaked at 5.6–5.7 GB resident (VmHWM, the memory-mapped file included) on this phone
+  with 11.4 GB of memory.
+- `Engine.close()` throws when called twice, so the app drops its reference before closing; releasing
+  twice is harmless.
+- All model calls run on one worker thread.
+
+## Microphone
+
+Hold **Hold to talk** and speak; releasing the button ends the recording, and so does the 30 s limit.
+Each model reads one window of about 30 s per message, so the app sends at most 30 s. The app records
+16 kHz mono 16-bit PCM (the `VOICE_RECOGNITION` source) and writes it as a WAV file for the runtime.
+A recording quieter than −60 dBFS RMS is reported as "No speech heard" and is not sent to the model.
+Without the microphone permission the app shows a sentence that says how to allow it; the clips still work.
+
+## The three clips
+
+`app/src/main/res/raw/` holds FLEURS test sentence 1698 read in Mandarin, English and Japanese
+([google/fleurs](https://huggingface.co/datasets/google/fleurs) revision `70bb2e84`, test split, id 1698;
+FLEURS, Conneau et al. 2022, licensed [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)). Changes:
+converted to 16-bit PCM and given one linear gain each, so that all three have an active RMS of −20 dBFS.
+The English reading is "Everything in the Universe is made of matter. All matter is made of tiny
+particles called atoms."
+
+## Device check
+
+[`AsrDeviceCheck.kt`](app/src/androidTest/kotlin/com/asrlitertlm/AsrDeviceCheck.kt) runs on a phone
+with at least one bundle pushed (as above). Turn the media volume up first: the microphone step plays a
+clip through the speaker.
+
+```bash
+./gradlew :app:installDebug :app:assembleDebugAndroidTest
+adb install -r -t app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk
+adb shell pm revoke com.asrlitertlm android.permission.RECORD_AUDIO
+adb shell am instrument -w -e class com.asrlitertlm.AsrDeviceCheck#check com.asrlitertlm.test/androidx.test.runner.AndroidJUnitRunner
+adb logcat -d -s asr-check | grep RESULT
+```
+
+It prints one line per step, `RESULT step=<name> ok=<true|false> model=<id> ...`, then
+`RESULT ok=<all>`. It starts with the microphone permission revoked and checks the sentence the app
+shows; then it grants the permission. For each bundle on the phone: load, the three clips (text equal to
+the expected sentence after removing punctuation and spaces), the microphone (CER ≤ 0.15), release
+twice, and a second load. Then a 33.6 s clip (cut to 30 s), a silent recording and a file that is not
+on the phone. With two or more bundles it also switches models without releasing. Add
+`-e class com.asrlitertlm.AsrDeviceCheck#gpu -e gpu_model fun-asr-nano-2512` for the GPU run.
+
+## Launch extras
+
+For recordings and tests; the app works without them.
+
+| Extra | Effect |
+|---|---|
+| `--es model <id>` | `qwen3-asr-1.7b`, `fun-asr-nano-2512` or `confucius4-r2t2` (default: the model used last) |
+| `--es backend gpu` | language model on the GPU; the audio encoder stays on the CPU |
+| `--ez autoplay true` | after loading: clips zh, en, ja, each played and then transcribed (`--ei delay_ms`, `--ei gap_ms`) |
+| `--ei mic_test_ms 9000` | after loading and `delay_ms`: record that long, then transcribe (`--ez mic_test_play true` plays clip en meanwhile) |
+
+The app logs one `STATE <name>` line per screen state and `LOAD` / `TRANSCRIBED` lines with the times
+under the tag `AsrLitertlm`.
+
+## Files
+
+| File | Role |
+|---|---|
+| `app/src/main/kotlin/com/asrlitertlm/AsrEngine.kt` | Engine and one Conversation per clip: load, transcribe (cut at 30 s), release (safe twice) |
+| `app/src/main/kotlin/com/asrlitertlm/ModelProfile.kt` | the three bundles: file name, Hugging Face id, answer format |
+| `app/src/main/kotlin/com/asrlitertlm/AsrSession.kt` | the app's one engine on one worker thread, events for the screen, the no-speech check |
+| `app/src/main/kotlin/com/asrlitertlm/MainActivity.kt` | picker, hold to talk, clip buttons, launch extras |
+| `app/src/main/kotlin/com/asrlitertlm/MicRecorder.kt` | 16 kHz mono recording, up to 30 s |
+| `app/src/main/kotlin/com/asrlitertlm/ClipPlayer.kt`, `PlayBar.kt` | clip playback through the speaker and its progress bar |
+| `app/src/main/kotlin/com/asrlitertlm/Wav.kt`, `TextMatch.kt` | WAV read, write and cut; transcript comparison (normalization and CER) |
+| `app/src/main/res/raw/fleurs_*_1698.wav` | the three clips |
+| `app/src/androidTest/kotlin/com/asrlitertlm/AsrDeviceCheck.kt` | device check |
+| `app/src/test/kotlin/com/asrlitertlm/AsrLogicTest.kt` | JVM tests: answer parsing, transcript comparison, WAV cut and levels |
+
+Build: AGP 9.3.1 with Kotlin 2.4.0 (the `litertlm-android` 0.17.1 AAR carries Kotlin 2.4 metadata),
+compileSdk 36, minSdk 31, arm64-v8a. The runtime version is pinned in `gradle.properties`.
+
+## License
+
+The app code is under the repository's MIT license. The clips are CC BY 4.0 (FLEURS, see above). Each
+model file has its own license (table above); none of them is in this directory.

android/app/build.gradle.kts

@@ -0,0 +1,39 @@
+// On-device speech recognition with three LiteRT-LM bundles (Qwen3-ASR-1.7B, Fun-ASR-Nano-2512, Confucius4-R2T2):
+// one Engine at a time, a new Conversation per clip, the language model and the audio encoder on the CPU.
+plugins { id("com.android.application") }
+
+val litertlmVersion: String = providers.gradleProperty("litertlmVersion").get()
+
+android {
+  namespace = "com.asrlitertlm"
+  compileSdk = 36
+
+  defaultConfig {
+    applicationId = "com.asrlitertlm"
+    minSdk = 31
+    targetSdk = 36
+    versionCode = 1
+    versionName = "1.0"
+    ndk { abiFilters += setOf("arm64-v8a") }
+    buildConfigField("String", "LITERTLM_VERSION", "\"$litertlmVersion\"")
+    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+  }
+
+  buildFeatures { buildConfig = true }
+
+  compileOptions {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+  }
+}
+
+dependencies {
+  // Brings gson, kotlin-reflect and kotlinx-coroutines-android (its POM).
+  implementation("com.google.ai.edge.litertlm:litertlm-android:$litertlmVersion")
+
+  testImplementation("junit:junit:4.13.2")
+
+  // Device check (app/src/androidTest): README "Device check" runs it with am instrument.
+  androidTestImplementation("androidx.test:runner:1.6.2")
+  androidTestImplementation("androidx.test.ext:junit:1.2.1")
+}

android/app/src/androidTest/kotlin/com/asrlitertlm/AsrDeviceCheck.kt

@@ -0,0 +1,417 @@
+package com.asrlitertlm
+
+import android.Manifest
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import java.io.File
+import java.util.Locale
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.Future
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Device check for the app's paths on a phone with the bundles pushed. One line per step under the log tag
+ * `asr-check`: `RESULT step=<name> ok=<bool> model=<id> ...`, then `RESULT ok=<all> scope=<test>`.
+ *
+ * [check] expects RECORD_AUDIO to be revoked when it starts (`adb shell pm revoke com.asrlitertlm
+ * android.permission.RECORD_AUDIO`): its first step is the microphone path without the permission; it then grants the
+ * permission itself. Per bundle on the phone: load, the three clips (the answer's text after normalization equals the
+ * expected sentence; the CER is printed when it does not), the microphone (clip en played through the speaker and
+ * picked up by the microphone, CER <= 0.15), release (a second release is harmless) and, when the load wrote the
+ * runtime cache, a second load. Then the failure paths: switching models, a clip longer than 30 s, a silent
+ * recording and a bundle that is not on the phone.
+ *
+ * [gpu] runs only with `-e gpu_model <id>`: the language model on the GPU, the audio encoder on the CPU.
+ */
+@RunWith(AndroidJUnit4::class)
+class AsrDeviceCheck {
+  private val instrumentation = InstrumentationRegistry.getInstrumentation()
+  private val context = instrumentation.targetContext
+  private val outcomes = mutableListOf<Boolean>()
+
+  @Test
+  fun check() {
+    AsrSession.init(context)
+    val present = ORDER.filter { AsrSession.isPresent(it) }
+    report(
+      "bundles",
+      present.isNotEmpty(),
+      null,
+      "present" to present.joinToString(",") { it.id }.ifEmpty { "none" },
+      "missing" to ORDER.filterNot { it in present }.joinToString(",") { it.id }.ifEmpty { "none" },
+      "dir" to AsrSession.modelDir.path,
+    )
+    if (present.isEmpty()) return finish("check")
+
+    val first = present.first()
+    val firstCache = cacheFiles(first)
+    val screen = launch(launchIntent(first))
+    try {
+      val firstLoad = awaitLoad(checkNotNull(AsrSession.lastLoad) { "the screen did not start a load" }, first)
+      val loads = mutableMapOf(first to (firstLoad to firstCache))
+
+      permissionStep(screen, first)
+      instrumentation.uiAutomation.grantRuntimePermission(context.packageName, Manifest.permission.RECORD_AUDIO)
+      report("grant", hasMicPermission(), null, "granted" to hasMicPermission())
+
+      for (profile in present) {
+        val load = loads[profile] ?: run {
+          val before = cacheFiles(profile)
+          awaitLoad(onScreen(screen) { it.selectModel(profile) }, profile)?.let { it to before }
+        }
+        if (load?.first == null) continue
+        reportLoad("load", profile, load.first!!, load.second)
+        clipSteps(profile, "clip")
+        micStep(screen, profile)
+        releaseStep(profile)
+        if (cacheState(profile, load.second) == "written") reloadStep(profile)
+      }
+      failurePaths(screen, present)
+    } finally {
+      close(screen)
+    }
+    finish("check")
+  }
+
+  @Test
+  fun gpu() {
+    val profile = ModelProfile.byId(InstrumentationRegistry.getArguments().getString("gpu_model"))
+    assumeTrue("run with -e gpu_model <id>", profile != null)
+    AsrSession.init(context)
+    val model = profile!!
+    if (!AsrSession.isPresent(model)) {
+      report("gpu-load", false, model, "reason" to "bundle not on the phone")
+      return finish("gpu")
+    }
+    val before = cacheFiles(model)
+    val screen = launch(launchIntent(model).putExtra(MainActivity.EXTRA_BACKEND, "gpu"))
+    try {
+      val info = awaitLoad(checkNotNull(AsrSession.lastLoad), model, step = "gpu-load")
+      if (info != null) {
+        reportLoad("gpu-load", model, info, before)
+        clipSteps(model, "gpu-clip")
+        releaseStep(model, step = "gpu-release")
+        val beforeReload = cacheFiles(model)
+        val reloaded = awaitLoad(AsrSession.load(model, LmBackend.GPU), model, step = "gpu-reload")
+        if (reloaded != null) reportLoad("gpu-reload", model, reloaded, beforeReload)
+        AsrSession.release().get(TIMEOUT_S, TimeUnit.SECONDS)
+      }
+    } finally {
+      close(screen)
+    }
+    finish("gpu")
+  }
+
+  // ---- steps --------------------------------------------------------------------------------------------------
+
+  /** The microphone path with RECORD_AUDIO revoked returns a sentence, records nothing, and a clip still works. */
+  private fun permissionStep(screen: MainActivity, profile: ModelProfile) {
+    val deniedAtStart = !hasMicPermission()
+    val result = micTest(screen, durationMs = 2000, play = false, waitS = 10)
+    val sentence = (result as? MicTestResult.Failed)?.message.orEmpty()
+    val clip = Clip.ALL[1]
+    val clipText = transcribeText(AsrSession.clipFile(clip), "clip:${clip.id}")
+    val clipOk = clipText != null && TextMatch.matches(EXPECTED.getValue(clip.id), clipText.answer.text)
+    report(
+      "permission",
+      deniedAtStart && sentence == MicRecorder.PERMISSION_MESSAGE && clipOk,
+      profile,
+      "denied_at_start" to deniedAtStart,
+      "message" to sentence.ifEmpty { result.toString() },
+      "clip_en_while_denied" to clipOk,
+    )
+  }
+
+  private fun clipSteps(profile: ModelProfile, step: String) {
+    for (clip in Clip.ALL) {
+      val expected = EXPECTED.getValue(clip.id)
+      val transcript = transcribeText(AsrSession.clipFile(clip), "clip:${clip.id}")
+      if (transcript == null) {
+        report(step, false, profile, "clip" to clip.label, "reason" to "no transcript")
+        continue
+      }
+      val text = transcript.answer.text
+      val match = TextMatch.matches(expected, text)
+      report(
+        step,
+        match,
+        profile,
+        "clip" to clip.label,
+        "backend" to transcript.lmBackend,
+        "audio_s" to fmt(transcript.sentSeconds),
+        "send_s" to fmt(transcript.sendMs / 1000),
+        "rtf" to fmt(transcript.rtf, digits = 3),
+        "conversation_s" to fmt(transcript.createConversationMs / 1000),
+        "language" to transcript.answer.language.ifEmpty { "-" },
+        "match" to match,
+        "cer" to fmt(TextMatch.cer(expected, text), digits = 4),
+        "text" to text,
+      )
+    }
+  }
+
+  /** Clip en through the speaker, picked up by the microphone (the mic_test launch extras' path). */
+  private fun micStep(screen: MainActivity, profile: ModelProfile) {
+    val result = micTest(screen, durationMs = MIC_TEST_MS, play = true, waitS = 90)
+    val outcome = (result as? MicTestResult.Finished)?.outcome
+    val transcript = (outcome as? TranscribeOutcome.Text)?.transcript
+    if (transcript == null) {
+      report("mic", false, profile, "result" to result.toString())
+      return
+    }
+    val expected = EXPECTED.getValue(Clip.ALL[1].id)
+    val cer = TextMatch.cer(expected, transcript.answer.text)
+    report(
+      "mic",
+      cer <= MIC_MAX_CER,
+      profile,
+      "rec_s" to fmt(transcript.audioSeconds),
+      "send_s" to fmt(transcript.sendMs / 1000),
+      "rtf" to fmt(transcript.rtf, digits = 3),
+      "cer" to fmt(cer, digits = 4),
+      "language" to transcript.answer.language.ifEmpty { "-" },
+      "text" to transcript.answer.text,
+    )
+  }
+
+  private fun releaseStep(profile: ModelProfile, step: String = "release") {
+    val first = runCatching { AsrSession.release().get(TIMEOUT_S, TimeUnit.SECONDS) }
+    val second = runCatching { AsrSession.release().get(TIMEOUT_S, TimeUnit.SECONDS) }
+    report(
+      step,
+      first.getOrNull() == true && second.getOrNull() == false && AsrSession.current == null,
+      profile,
+      "first" to (first.getOrNull() ?: first.exceptionOrNull()),
+      "second" to (second.getOrNull() ?: second.exceptionOrNull()),
+      "vmrss_mb" to statusMb("VmRSS"),
+    )
+  }
+
+  /** A second load, now that the first wrote the runtime cache: the load time a user sees from then on. */
+  private fun reloadStep(profile: ModelProfile) {
+    val before = cacheFiles(profile)
+    val info = awaitLoad(AsrSession.load(profile), profile, step = "reload") ?: return
+    reportLoad("reload", profile, info, before)
+    AsrSession.release().get(TIMEOUT_S, TimeUnit.SECONDS)
+  }
+
+  private fun failurePaths(screen: MainActivity, present: List<ModelProfile>) {
+    // Switching: load one bundle, then pick another without releasing; the screen's path closes the first.
+    val to = present.first()
+    val from = present.firstOrNull { it != to }
+    if (from == null) {
+      // Not a result: the phone holds one bundle (with its runtime cache) at a time when storage is short.
+      Log.i(TAG, "NOTE step=switch not_run=\"one bundle on the phone\" model=${to.id}")
+    } else {
+      awaitLoad(onScreen(screen) { it.selectModel(from) }, from, step = "switch")
+      val switched = awaitLoad(onScreen(screen) { it.selectModel(to) }, to, step = "switch")
+      val clip = Clip.ALL[1]
+      val text = transcribeText(AsrSession.clipFile(clip), "clip:${clip.id}")?.answer?.text
+      report(
+        "switch",
+        switched != null && AsrSession.current?.profile == to && text != null &&
+          TextMatch.matches(EXPECTED.getValue(clip.id), text),
+        to,
+        "from" to from.id,
+        "load_s" to (switched?.let { fmt(it.loadMs / 1000) } ?: "-"),
+        "vmrss_mb" to statusMb("VmRSS"),
+        "text" to (text ?: "-"),
+      )
+    }
+    if (AsrSession.current == null) awaitLoad(AsrSession.load(to), to, step = "long-clip")
+
+    // Longer than one window: the app sends the first 30 s and does not crash.
+    val long = File(context.cacheDir, "long-check.wav")
+    val pcm = (Clip.ALL + Clip.ALL[1]).map { Wav.pcm16(AsrSession.clipFile(it)).data }
+    Wav.writeMono16(long, pcm.fold(ByteArray(0)) { all, part -> all + part }, MicRecorder.SAMPLE_RATE)
+    val longText = transcribeText(long, "long-clip")
+    report(
+      "long-clip",
+      longText != null && longText.audioSeconds > 31.0 && kotlin.math.abs(longText.sentSeconds - 30.0) < 0.01 &&
+        longText.answer.text.isNotEmpty(),
+      AsrSession.current?.profile,
+      "audio_s" to fmt(longText?.audioSeconds ?: Wav.seconds(long)),
+      "sent_s" to (longText?.let { fmt(it.sentSeconds) } ?: "-"),
+      "send_s" to (longText?.let { fmt(it.sendMs / 1000) } ?: "-"),
+      "text" to (longText?.answer?.text ?: "-"),
+    )
+
+    // A silent recording: "no speech", and the model is not called.
+    val silent = File(context.cacheDir, "silence-check.wav")
+    Wav.writeMono16(silent, ByteArray(MicRecorder.SAMPLE_RATE * 2 * 3), MicRecorder.SAMPLE_RATE)
+    val silence = runCatching { AsrSession.transcribe(silent, "silence").get(TIMEOUT_S, TimeUnit.SECONDS) }
+    report(
+      "silence",
+      silence.getOrNull() is TranscribeOutcome.NoSpeech,
+      AsrSession.current?.profile,
+      "result" to (silence.getOrNull() ?: silence.exceptionOrNull()),
+    )
+
+    // A bundle that is not on the phone: a sentence naming the file and where to push it; the loaded model stays.
+    val loadedBefore = AsrSession.current?.profile
+    val ghost = ModelProfile.QWEN3_ASR_1_7B.copy(fileName = "not-on-this-phone.litertlm")
+    val missing =
+      runCatching { AsrSession.load(ghost, bundle = AsrSession.bundleFile(ghost)).get(TIMEOUT_S, TimeUnit.SECONDS) }
+    val message = ((missing.exceptionOrNull() as? ExecutionException)?.cause as? AsrException)?.message.orEmpty()
+    report(
+      "missing-bundle",
+      missing.isFailure && message.contains("not-on-this-phone.litertlm") &&
+        message.contains(AsrSession.modelDir.path) && AsrSession.current?.profile == loadedBefore,
+      loadedBefore,
+      "message" to message.ifEmpty { missing.toString() },
+      "still_loaded" to (AsrSession.current?.profile?.id ?: "none"),
+    )
+    releaseStep(loadedBefore ?: to, step = "release-final")
+    long.delete()
+    silent.delete()
+  }
+
+  // ---- helpers ------------------------------------------------------------------------------------------------
+
+  private fun launchIntent(profile: ModelProfile) =
+    Intent(context, MainActivity::class.java)
+      .putExtra(MainActivity.EXTRA_MODEL, profile.id)
+      .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+
+  /** Starts the screen in the foreground (the microphone records only for a visible app) and waits until it runs. */
+  private fun launch(intent: Intent): MainActivity = instrumentation.startActivitySync(intent) as MainActivity
+
+  private fun close(screen: MainActivity) {
+    instrumentation.runOnMainSync { screen.finish() }
+    instrumentation.waitForIdleSync()
+  }
+
+  private fun <T> onScreen(screen: MainActivity, block: (MainActivity) -> T): T {
+    val value = AtomicReference<T>()
+    instrumentation.runOnMainSync { value.set(block(screen)) }
+    return value.get()
+  }
+
+  private fun awaitLoad(future: Future<LoadInfo>?, profile: ModelProfile, step: String = "load"): LoadInfo? {
+    if (future == null) {
+      report(step, false, profile, "reason" to "the screen did not load it")
+      return null
+    }
+    return try {
+      future.get(LOAD_TIMEOUT_S, TimeUnit.SECONDS)
+    } catch (e: ExecutionException) {
+      report(step, false, profile, "message" to (e.cause?.message ?: e.toString()))
+      null
+    }
+  }
+
+  private fun transcribeText(wav: File, source: String): Transcript? =
+    try {
+      (AsrSession.transcribe(wav, source).get(TIMEOUT_S, TimeUnit.SECONDS) as? TranscribeOutcome.Text)?.transcript
+    } catch (e: ExecutionException) {
+      Log.e(TAG, "transcription failed: $source", e.cause)
+      null
+    }
+
+  private fun micTest(screen: MainActivity, durationMs: Long, play: Boolean, waitS: Long): MicTestResult? {
+    val done = CountDownLatch(1)
+    val result = AtomicReference<MicTestResult>()
+    instrumentation.runOnMainSync {
+      screen.runMicTest(durationMs, play) {
+        result.set(it)
+        done.countDown()
+      }
+    }
+    done.await(waitS, TimeUnit.SECONDS)
+    return result.get()
+  }
+
+  private fun reportLoad(step: String, profile: ModelProfile, info: LoadInfo, before: Map<String, CacheFile>) {
+    report(
+      step,
+      true,
+      profile,
+      "backend" to info.lmBackend,
+      "load_s" to fmt(info.loadMs / 1000),
+      "initialize_s" to fmt(info.initializeMs / 1000),
+      "first_conversation_s" to fmt(info.firstConversationMs / 1000),
+      "cache" to cacheState(profile, before),
+      "cache_mb" to cacheFiles(profile).values.sumOf { it.bytes } / 1_000_000,
+      "threads" to AsrEngine.CPU_THREADS,
+      "vmhwm_mb" to statusMb("VmHWM"),
+      "vmrss_mb" to statusMb("VmRSS"),
+      "mem_available_mb" to memAvailableMb(),
+    )
+  }
+
+  /** One runtime cache file: the runtime names them after the bundle file. */
+  private data class CacheFile(val bytes: Long, val modified: Long)
+
+  private fun cacheFiles(profile: ModelProfile): Map<String, CacheFile> =
+    context.cacheDir
+      .listFiles { file -> file.name.startsWith(profile.fileName) }
+      .orEmpty()
+      .associate { it.name to CacheFile(it.length(), it.lastModified()) }
+
+  /** "loaded" when the load left the cache files as they were, "written" when it created or rewrote them. */
+  private fun cacheState(profile: ModelProfile, before: Map<String, CacheFile>): String =
+    if (cacheFiles(profile) == before && before.isNotEmpty()) "loaded" else "written"
+
+  private fun hasMicPermission(): Boolean =
+    context.checkSelfPermission(Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
+
+  private fun statusMb(key: String): Long =
+    File("/proc/self/status").readLines().firstOrNull { it.startsWith("$key:") }
+      ?.trim()?.split(Regex("\\s+"))?.getOrNull(1)?.toLongOrNull()?.div(1024) ?: -1
+
+  private fun memAvailableMb(): Long =
+    File("/proc/meminfo").readLines().firstOrNull { it.startsWith("MemAvailable:") }
+      ?.trim()?.split(Regex("\\s+"))?.getOrNull(1)?.toLongOrNull()?.div(1024) ?: -1
+
+  private fun report(step: String, ok: Boolean, profile: ModelProfile?, vararg fields: Pair<String, Any?>) {
+    outcomes += ok
+    val line = StringBuilder("RESULT step=$step ok=$ok model=${profile?.id ?: "-"}")
+    for ((key, value) in fields) line.append(' ').append(key).append('=').append(quote(value.toString()))
+    Log.i(TAG, line.toString())
+  }
+
+  private fun finish(scope: String) {
+    val all = outcomes.isNotEmpty() && outcomes.all { it }
+    Log.i(TAG, "RESULT ok=$all scope=$scope steps=${outcomes.size} failed=${outcomes.count { !it }}")
+    assertTrue("a device check step failed (logcat -s $TAG)", all)
+  }
+
+  private fun quote(value: String): String =
+    if (value.isNotEmpty() && value.none { it.isWhitespace() || it == '"' }) value
+    else "\"" + value.replace("\\", "\\\\").replace("\"", "\\\"").replace("\n", "\\n") + "\""
+
+  private fun fmt(value: Double, digits: Int = 2) = String.format(Locale.US, "%.${digits}f", value)
+
+  private companion object {
+    const val TAG = "asr-check"
+    const val LOAD_TIMEOUT_S = 300L
+    const val TIMEOUT_S = 120L
+    const val MIC_TEST_MS = 9000L
+    const val MIC_MAX_CER = 0.15
+
+    /** Bundles in the order the check loads them. */
+    val ORDER =
+      listOf(ModelProfile.QWEN3_ASR_1_7B, ModelProfile.CONFUCIUS4_R2T2, ModelProfile.FUN_ASR_NANO_2512)
+
+    /**
+     * The expected sentences: Qwen3-ASR-1.7B's answers on the Mac CPU (litert-lm-api 0.17.1), which the S26 app runs
+     * of 2026-10-03 matched. Fun-ASR-Nano-2512 and Confucius4-R2T2 give the same sentences on the Mac CPU.
+     */
+    val EXPECTED =
+      mapOf(
+        "fleurs_cmn_1698" to "宇宙中的一切都由物质构成，而所有的物质都由被称为原子的微小颗粒组成。",
+        "fleurs_en_1698" to
+          "Everything in the universe is made of matter. All matter is made of tiny particles called atoms.",
+        "fleurs_ja_1698" to "宇宙に存在するあらゆるものは物質でできています。あらゆる物質は原子と呼ばれる微小な粒子でできています。",
+      )
+  }
+}

android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+
+    <application
+        android:allowBackup="false"
+        android:label="@string/app_name"
+        android:largeHeap="true"
+        android:theme="@style/Theme.AsrLitertlm">
+
+        <!-- Only for the language model on the GPU (launch extra backend=gpu); the CPU path does not need it. -->
+        <uses-native-library
+            android:name="libOpenCL.so"
+            android:required="false" />
+
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:launchMode="singleTask"
+            android:screenOrientation="portrait">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>

android/app/src/main/kotlin/com/asrlitertlm/AsrEngine.kt

@@ -0,0 +1,181 @@
+package com.asrlitertlm
+
+import android.os.SystemClock
+import com.google.ai.edge.litertlm.Backend
+import com.google.ai.edge.litertlm.Content
+import com.google.ai.edge.litertlm.Contents
+import com.google.ai.edge.litertlm.ConversationConfig
+import com.google.ai.edge.litertlm.Engine
+import com.google.ai.edge.litertlm.EngineConfig
+import com.google.ai.edge.litertlm.Message
+import com.google.ai.edge.litertlm.SamplerConfig
+import java.io.File
+
+/** Which processor runs the language model. The audio encoder always runs on the CPU (the GPU delegate rejects it). */
+enum class LmBackend {
+  CPU,
+  GPU,
+}
+
+/** A failure the app shows as a sentence instead of crashing. */
+class AsrException(message: String, cause: Throwable? = null) : Exception(message, cause)
+
+/** What one load cost. "Engine load" = Engine.initialize() plus the first conversation, which creates the encoder. */
+data class LoadInfo(
+  val profile: ModelProfile,
+  val bundle: File,
+  val bundleBytes: Long,
+  val lmBackend: LmBackend,
+  val initializeMs: Double,
+  val firstConversationMs: Double,
+) {
+  val loadMs: Double
+    get() = initializeMs + firstConversationMs
+}
+
+/** One transcription. [sendMs] is the wall time of sendMessage(), from sending the clip to the full answer. */
+data class Transcript(
+  val profile: ModelProfile,
+  val lmBackend: LmBackend,
+  val raw: String,
+  val answer: Answer,
+  /** Length of the audio the app received. */
+  val audioSeconds: Double,
+  /** Length of the audio sent to the model (at most [AsrEngine.MAX_AUDIO_SECONDS]). */
+  val sentSeconds: Double,
+  val sendMs: Double,
+  val createConversationMs: Double,
+) {
+  /** Real-time factor: transcription time over the length of the audio the model heard. */
+  val rtf: Double
+    get() = sendMs / 1000.0 / sentSeconds
+}
+
+/**
+ * One loaded `.litertlm` bundle and the calls every model in [ModelProfile.ALL] shares: an Engine with the language
+ * model on the CPU (or the GPU) and the audio encoder on the CPU, a new Conversation per clip, one user message that
+ * holds only the audio file, greedy sampling.
+ *
+ * Not thread-safe: the app calls it from one worker thread ([AsrSession]).
+ */
+class AsrEngine(private val cacheDir: File) : AutoCloseable {
+  private var engine: Engine? = null
+
+  /** The bundle in memory, or null. */
+  var loaded: LoadInfo? = null
+    private set
+
+  /**
+   * Loads [profile] from [bundle], closing the engine loaded before. A missing file or a runtime failure becomes an
+   * [AsrException] with a sentence for the screen; a missing file leaves the loaded engine as it was.
+   */
+  fun load(profile: ModelProfile, bundle: File, lmBackend: LmBackend = LmBackend.CPU): LoadInfo {
+    if (!bundle.isFile) throw AsrException(missingBundleMessage(profile, bundle.parentFile))
+    // One engine at a time: two 2.7 GB bundles in memory at once would cross what the phone gives one app.
+    release()
+    val lm = if (lmBackend == LmBackend.GPU) Backend.GPU() else Backend.CPU(threadCount = CPU_THREADS)
+    val config =
+      EngineConfig(
+        modelPath = bundle.path,
+        backend = lm,
+        audioBackend = Backend.CPU(threadCount = CPU_THREADS),
+        cacheDir = cacheDir.path,
+      )
+    val newEngine = Engine(config)
+    val start = SystemClock.elapsedRealtimeNanos()
+    val initialized: Long
+    try {
+      newEngine.initialize()
+      initialized = SystemClock.elapsedRealtimeNanos()
+      // The runtime creates the audio encoder with the first conversation; do it here so it counts as loading.
+      newEngine.createConversation(conversationConfig(profile)).close()
+    } catch (t: Throwable) {
+      if (newEngine.isInitialized()) runCatching { newEngine.close() }
+      throw AsrException("Could not load ${profile.fileName} (${lmBackend.name}): ${t.message ?: t}", t)
+    }
+    val ready = SystemClock.elapsedRealtimeNanos()
+    engine = newEngine
+    return LoadInfo(
+        profile = profile,
+        bundle = bundle,
+        bundleBytes = bundle.length(),
+        lmBackend = lmBackend,
+        initializeMs = (initialized - start) / 1e6,
+        firstConversationMs = (ready - initialized) / 1e6,
+      )
+      .also { loaded = it }
+  }
+
+  /**
+   * Transcribes a 16 kHz mono 16-bit wav. Audio longer than [MAX_AUDIO_SECONDS] is cut there first ([scratch] holds
+   * the cut copy): each model reads one window of about 30 s per message.
+   */
+  fun transcribe(wav: File, scratch: File): Transcript {
+    val currentEngine = engine ?: throw AsrException("No model is loaded.")
+    val info = loaded ?: throw AsrException("No model is loaded.")
+    val audioSeconds = Wav.seconds(wav)
+    val sent = Wav.trimmed(wav, MAX_AUDIO_SECONDS, scratch)
+    val sentSeconds = if (sent === wav) audioSeconds else Wav.seconds(sent)
+    val created: Long
+    val sendStart: Long
+    val sendEnd: Long
+    val raw: String
+    val start = SystemClock.elapsedRealtimeNanos()
+    try {
+      currentEngine.createConversation(conversationConfig(info.profile)).use { conversation ->
+        created = SystemClock.elapsedRealtimeNanos()
+        val message = Message.user(Contents.of(Content.AudioFile(sent.absolutePath)))
+        sendStart = SystemClock.elapsedRealtimeNanos()
+        raw = conversation.sendMessage(message).toString()
+        sendEnd = SystemClock.elapsedRealtimeNanos()
+      }
+    } catch (t: Throwable) {
+      throw AsrException("${info.profile.displayName} could not transcribe this clip: ${t.message ?: t}", t)
+    }
+    return Transcript(
+      profile = info.profile,
+      lmBackend = info.lmBackend,
+      raw = raw,
+      answer = info.profile.parse(raw),
+      audioSeconds = audioSeconds,
+      sentSeconds = sentSeconds,
+      sendMs = (sendEnd - sendStart) / 1e6,
+      createConversationMs = (created - start) / 1e6,
+    )
+  }
+
+  /**
+   * Closes the engine and returns true, or returns false when none is loaded. Safe to call twice: the runtime's own
+   * Engine.close() throws on a second call, so the reference is dropped before closing.
+   */
+  fun release(): Boolean {
+    val current = engine ?: return false
+    engine = null
+    loaded = null
+    current.close()
+    return true
+  }
+
+  override fun close() {
+    release()
+  }
+
+  companion object {
+    /** CPU threads for the language model and the audio encoder (the model cards' Galaxy S26 rows). */
+    const val CPU_THREADS = 4
+
+    /** The longest audio sent in one message; longer audio is cut here. */
+    const val MAX_AUDIO_SECONDS = 30.0
+
+    fun conversationConfig(profile: ModelProfile) =
+      ConversationConfig(
+        samplerConfig = SamplerConfig(topK = 1, topP = 1.0, temperature = 0.0),
+        maxOutputToken = profile.maxOutputTokens,
+      )
+
+    /** The sentence the picker and a failed load show for a bundle that is not on the phone. */
+    fun missingBundleMessage(profile: ModelProfile, directory: File?): String =
+      "${profile.fileName} is not on this phone. Download it from huggingface.co/${profile.hubRepo} and push it " +
+        "to ${directory?.path ?: "the app's files directory"}/ with adb (see README)."
+  }
+}

android/app/src/main/kotlin/com/asrlitertlm/AsrSession.kt

@@ -0,0 +1,248 @@
+package com.asrlitertlm
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import java.io.File
+import java.io.IOException
+import java.util.Locale
+import java.util.concurrent.Callable
+import java.util.concurrent.CopyOnWriteArrayList
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.concurrent.Future
+
+/** One bundled clip: FLEURS test sentence 1698 read in one language (google/fleurs, CC BY 4.0). */
+data class Clip(val id: String, val label: String, val rawRes: Int) {
+  companion object {
+    val ALL =
+      listOf(
+        Clip("fleurs_cmn_1698", "zh", R.raw.fleurs_cmn_1698),
+        Clip("fleurs_en_1698", "en", R.raw.fleurs_en_1698),
+        Clip("fleurs_ja_1698", "ja", R.raw.fleurs_ja_1698),
+      )
+  }
+}
+
+/** The end of one transcription request. */
+sealed interface TranscribeOutcome {
+  data class Text(val transcript: Transcript) : TranscribeOutcome
+
+  /** The audio was close to digital silence, so the model was not called. */
+  data class NoSpeech(val levels: Wav.Levels, val seconds: Double) : TranscribeOutcome
+}
+
+/** What the session did, delivered to listeners on the main thread. */
+sealed interface AsrEvent {
+  data class Loading(val profile: ModelProfile, val lmBackend: LmBackend) : AsrEvent
+
+  data class Loaded(val info: LoadInfo) : AsrEvent
+
+  data class LoadFailed(val profile: ModelProfile, val message: String) : AsrEvent
+
+  data class Transcribing(val source: String) : AsrEvent
+
+  data class Transcribed(val source: String, val outcome: TranscribeOutcome) : AsrEvent
+
+  data class TranscribeFailed(val source: String, val message: String) : AsrEvent
+
+  data class Released(val profile: ModelProfile) : AsrEvent
+}
+
+/**
+ * The app's one engine, shared by the screen and the device check. Every model call runs on one worker thread (an
+ * Engine is not called from two threads), and one bundle is in memory at a time. The methods return futures for
+ * callers that wait (the device check) and publish [AsrEvent]s for the screen.
+ */
+object AsrSession {
+  private const val TAG = "AsrLitertlm"
+
+  /** Recordings quieter than this (RMS) are reported as no speech instead of being sent to the model. */
+  const val NO_SPEECH_RMS_DBFS = -60.0
+
+  private val worker: ExecutorService = Executors.newSingleThreadExecutor { Thread(it, "asr-worker") }
+  private val main = Handler(Looper.getMainLooper())
+  private val listeners = CopyOnWriteArrayList<(AsrEvent) -> Unit>()
+
+  @Volatile private var engine: AsrEngine? = null
+  private lateinit var modelDirectory: File
+  private lateinit var cacheDirectory: File
+  private lateinit var appContext: Context
+
+  /** The bundle in memory, or null. */
+  @Volatile
+  var current: LoadInfo? = null
+    private set
+
+  /** The last load request, so that a caller can wait for a load the screen started. */
+  @Volatile
+  var lastLoad: Future<LoadInfo>? = null
+    private set
+
+  /** Where the app looks for the bundles: `/sdcard/Android/data/com.asrlitertlm/files`. */
+  val modelDir: File
+    get() = modelDirectory
+
+  fun init(context: Context) {
+    synchronized(this) {
+      if (engine != null) return
+      appContext = context.applicationContext
+      modelDirectory = appContext.getExternalFilesDir(null) ?: appContext.filesDir
+      cacheDirectory = appContext.cacheDir
+      engine = AsrEngine(cacheDirectory)
+    }
+  }
+
+  fun bundleFile(profile: ModelProfile): File = File(modelDirectory, profile.fileName)
+
+  fun isPresent(profile: ModelProfile): Boolean = bundleFile(profile).isFile
+
+  /** The clip as a wav file the runtime can open (copied out of the APK once). */
+  fun clipFile(clip: Clip): File {
+    val file = File(cacheDirectory, "${clip.id}.wav")
+    if (!file.isFile) {
+      val partial = File(cacheDirectory, "${clip.id}.wav.part")
+      appContext.resources.openRawResource(clip.rawRes).use { input ->
+        partial.outputStream().use { input.copyTo(it) }
+      }
+      check(partial.renameTo(file)) { "could not write $file" }
+    }
+    return file
+  }
+
+  fun addListener(listener: (AsrEvent) -> Unit) {
+    listeners.add(listener)
+  }
+
+  fun removeListener(listener: (AsrEvent) -> Unit) {
+    listeners.remove(listener)
+  }
+
+  /** Loads [profile] (closing the bundle loaded before). [bundle] defaults to the file in [modelDir]. */
+  fun load(
+    profile: ModelProfile,
+    lmBackend: LmBackend = LmBackend.CPU,
+    bundle: File = bundleFile(profile),
+  ): Future<LoadInfo> =
+    worker
+      .submit(
+        Callable {
+          publish(AsrEvent.Loading(profile, lmBackend))
+          val asr = checkNotNull(engine) { "AsrSession.init() was not called" }
+          try {
+            asr.load(profile, bundle, lmBackend).also { info ->
+              current = info
+              Log.i(
+                TAG,
+                String.format(
+                  Locale.US,
+                  "LOAD model=%s backend=%s load_ms=%.1f initialize_ms=%.1f first_conversation_ms=%.1f bytes=%d",
+                  profile.id,
+                  lmBackend,
+                  info.loadMs,
+                  info.initializeMs,
+                  info.firstConversationMs,
+                  info.bundleBytes,
+                ),
+              )
+              publish(AsrEvent.Loaded(info))
+            }
+          } catch (e: AsrException) {
+            current = asr.loaded
+            Log.e(TAG, "LOAD_FAILED model=${profile.id} backend=$lmBackend: ${e.message}", e.cause)
+            publish(AsrEvent.LoadFailed(profile, e.message ?: e.toString()))
+            throw e
+          }
+        }
+      )
+      .also { lastLoad = it }
+
+  /**
+   * Transcribes a 16 kHz mono 16-bit wav with the loaded bundle; [source] names the input in events and logs
+   * ("clip:<id>", "mic"). Near-silent audio returns [TranscribeOutcome.NoSpeech] without calling the model.
+   */
+  fun transcribe(wav: File, source: String): Future<TranscribeOutcome> =
+    worker.submit(
+      Callable {
+        publish(AsrEvent.Transcribing(source))
+        val asr = checkNotNull(engine) { "AsrSession.init() was not called" }
+        try {
+          val pcm =
+            try {
+              Wav.pcm16(wav)
+            } catch (e: IOException) {
+              throw AsrException("Could not read ${wav.name}: ${e.message}", e)
+            } catch (e: RuntimeException) { // not a wav, no data chunk, not 16-bit
+              throw AsrException("Could not read ${wav.name}: ${e.message}", e)
+            }
+          val levels = Wav.levels(pcm.data)
+          val outcome =
+            if (levels.rmsDbfs < NO_SPEECH_RMS_DBFS) {
+              TranscribeOutcome.NoSpeech(levels, pcm.seconds)
+            } else {
+              TranscribeOutcome.Text(asr.transcribe(wav, File(cacheDirectory, "sent.wav")))
+            }
+          log(source, outcome)
+          publish(AsrEvent.Transcribed(source, outcome))
+          outcome
+        } catch (e: AsrException) {
+          Log.e(TAG, "TRANSCRIBE_FAILED source=$source: ${e.message}", e.cause)
+          publish(AsrEvent.TranscribeFailed(source, e.message ?: e.toString()))
+          throw e
+        }
+      }
+    )
+
+  /** Closes the loaded bundle; the future holds false when none was loaded (a second call is harmless). */
+  fun release(): Future<Boolean> =
+    worker.submit(
+      Callable {
+        val profile = current?.profile
+        val closed = checkNotNull(engine) { "AsrSession.init() was not called" }.release()
+        current = null
+        Log.i(TAG, "RELEASE model=${profile?.id} closed=$closed")
+        if (closed && profile != null) publish(AsrEvent.Released(profile))
+        closed
+      }
+    )
+
+  private fun log(source: String, outcome: TranscribeOutcome) {
+    when (outcome) {
+      is TranscribeOutcome.Text -> {
+        val transcript = outcome.transcript
+        Log.i(
+          TAG,
+          String.format(
+            Locale.US,
+            "TRANSCRIBED source=%s model=%s backend=%s audio_s=%.2f sent_s=%.2f send_ms=%.1f rtf=%.3f raw=%s",
+            source,
+            transcript.profile.id,
+            transcript.lmBackend,
+            transcript.audioSeconds,
+            transcript.sentSeconds,
+            transcript.sendMs,
+            transcript.rtf,
+            transcript.raw.replace('\n', ' '),
+          ),
+        )
+      }
+      is TranscribeOutcome.NoSpeech ->
+        Log.i(
+          TAG,
+          String.format(
+            Locale.US,
+            "NO_SPEECH source=%s seconds=%.2f rms_dbfs=%.1f peak_dbfs=%.1f",
+            source,
+            outcome.seconds,
+            outcome.levels.rmsDbfs,
+            outcome.levels.peakDbfs,
+          ),
+        )
+    }
+  }
+
+  private fun publish(event: AsrEvent) {
+    main.post { listeners.forEach { it(event) } }
+  }
+}

android/app/src/main/kotlin/com/asrlitertlm/ClipPlayer.kt

@@ -0,0 +1,99 @@
+package com.asrlitertlm
+
+import android.media.AudioAttributes
+import android.media.AudioFormat
+import android.media.AudioTrack
+import android.os.Handler
+import android.os.Looper
+import java.io.File
+
+/**
+ * Plays one 16-bit wav through the phone's speaker. [onDone] runs on the main thread once the last sample has reached
+ * the mixer plus the output latency (about 0.2 s on the Galaxy S26), or with a sentence when playback failed.
+ */
+class ClipPlayer {
+  private val main = Handler(Looper.getMainLooper())
+  private var track: AudioTrack? = null
+  private var finish: Runnable? = null
+
+  /** Starts [wav]; [onProgress] gets the played share (0..1) every 50 ms. Stops a clip that is still playing. */
+  fun play(wav: File, onProgress: (Float) -> Unit, onDone: (failure: String?) -> Unit) {
+    stop()
+    val newTrack: AudioTrack
+    val frames: Int
+    val rate: Int
+    try {
+      val pcm = Wav.pcm16(wav)
+      frames = pcm.frames
+      rate = pcm.sampleRate
+      newTrack =
+        AudioTrack.Builder()
+          .setAudioAttributes(
+            AudioAttributes.Builder()
+              .setUsage(AudioAttributes.USAGE_MEDIA)
+              .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+              .build()
+          )
+          .setAudioFormat(
+            AudioFormat.Builder()
+              .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
+              .setSampleRate(pcm.sampleRate)
+              .setChannelMask(
+                if (pcm.channels == 1) AudioFormat.CHANNEL_OUT_MONO else AudioFormat.CHANNEL_OUT_STEREO
+              )
+              .build()
+          )
+          .setTransferMode(AudioTrack.MODE_STATIC)
+          .setBufferSizeInBytes(pcm.data.size)
+          .build()
+      check(newTrack.write(pcm.data, 0, pcm.data.size) == pcm.data.size) { "AudioTrack took a partial buffer" }
+    } catch (e: RuntimeException) {
+      onDone("Could not play ${wav.name}: ${e.message ?: e}")
+      return
+    }
+    val done = Runnable {
+      if (track === newTrack) {
+        stop()
+        onDone(null)
+      }
+    }
+    finish = done
+    track = newTrack
+    newTrack.positionNotificationPeriod = rate / PROGRESS_PER_SECOND
+    newTrack.notificationMarkerPosition = maxOf(1, frames - rate / MARKER_LEAD_PER_SECOND)
+    newTrack.setPlaybackPositionUpdateListener(
+      object : AudioTrack.OnPlaybackPositionUpdateListener {
+        override fun onMarkerReached(t: AudioTrack) {
+          main.removeCallbacks(done)
+          main.postDelayed(done, OUTPUT_LATENCY_MS)
+        }
+
+        override fun onPeriodicNotification(t: AudioTrack) {
+          if (track === t) onProgress((t.playbackHeadPosition.toFloat() / frames).coerceIn(0f, 1f))
+        }
+      },
+      main,
+    )
+    newTrack.play()
+    // A marker that never fires (a muted or rerouted output) still ends the clip.
+    main.postDelayed(done, frames * 1000L / rate + FALLBACK_SLACK_MS)
+  }
+
+  /** Stops and frees the current clip without calling its onDone. */
+  fun stop() {
+    finish?.let { main.removeCallbacks(it) }
+    finish = null
+    track?.let {
+      runCatching { it.stop() }
+      it.release()
+    }
+    track = null
+  }
+
+  private companion object {
+    const val PROGRESS_PER_SECOND = 20
+    const val MARKER_LEAD_PER_SECOND = 50 // the marker sits 20 ms before the last frame
+    const val OUTPUT_LATENCY_MS = 250L
+    const val FALLBACK_SLACK_MS = 3_000L
+  }
+}

android/app/src/main/kotlin/com/asrlitertlm/MainActivity.kt

@@ -0,0 +1,712 @@
+package com.asrlitertlm
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.graphics.Typeface
+import android.graphics.drawable.GradientDrawable
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.style.ForegroundColorSpan
+import android.text.style.StyleSpan
+import android.util.Log
+import android.util.TypedValue
+import android.view.Gravity
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import android.view.WindowInsets
+import android.view.WindowManager
+import android.widget.LinearLayout
+import android.widget.ScrollView
+import android.widget.TextView
+import java.io.File
+import java.util.Locale
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Future
+
+/** How a microphone test ended (see [MainActivity.runMicTest]). */
+sealed interface MicTestResult {
+  data class Finished(val outcome: TranscribeOutcome) : MicTestResult
+
+  data class Failed(val message: String) : MicTestResult
+}
+
+/**
+ * Speech to text on the phone with one of three LiteRT-LM bundles: pick a model, hold the microphone button and speak
+ * (up to 30 s), or play one of three bundled clips. The bundle's language model and audio encoder run on the CPU
+ * (4 threads); every number on screen is measured by this app: "engine load" = Engine.initialize() plus the first
+ * conversation, "transcribe" = the wall time of sendMessage(), RTF = that time over the clip length.
+ *
+ * The bundles are read from /sdcard/Android/data/com.asrlitertlm/files/<file name> (adb push, see README). Launch
+ * extras, for recordings and the device check (all optional):
+ * ```
+ *   --es model <id>          qwen3-asr-1.7b | fun-asr-nano-2512 | confucius4-r2t2 (default: the last one used)
+ *   --es backend gpu         language model on the GPU (audio encoder stays on the CPU)
+ *   --ez autoplay true       after READY: wait delay_ms, then clips zh -> en -> ja (each played, then transcribed)
+ *   --ei delay_ms 3000       with gap_ms between one transcript and the next clip
+ *   --ei gap_ms 2500
+ *   --ei mic_test_ms 9000    after READY and delay_ms: record that long without touching the screen, then transcribe
+ *   --ez mic_test_play true  and play clip en through the speaker meanwhile (needs RECORD_AUDIO granted already)
+ * ```
+ * Logs go to the tag AsrLitertlm: one `STATE <name>` line per screen state, `LOAD` and `TRANSCRIBED` lines with the
+ * measured times.
+ */
+class MainActivity : Activity() {
+  private val main = Handler(Looper.getMainLooper())
+  private val player = ClipPlayer()
+  private lateinit var recorder: MicRecorder
+  private val onEvent: (AsrEvent) -> Unit = { handle(it) }
+
+  private var busy = false
+  private var lmBackend = LmBackend.CPU
+  private var selected: ModelProfile? = null
+  private var micCallback: ((MicTestResult) -> Unit)? = null
+  private var extrasPending = false
+  private var autoplayIndex = -1
+  private var pendingNotice: String? = null
+
+  private lateinit var pill: TextView
+  private lateinit var engineLine: TextView
+  private lateinit var pickerRows: Map<ModelProfile, TextView>
+  private lateinit var sourceLine: TextView
+  private lateinit var bar: PlayBar
+  private lateinit var body: TextView
+  private lateinit var languageLine: TextView
+  private lateinit var timeLine: TextView
+  private lateinit var deviceLine: TextView
+  private lateinit var clipButtons: List<TextView>
+  private lateinit var micButton: TextView
+
+  private val deviceName: String
+    get() = if (Build.MODEL.startsWith("SM-S942")) "Galaxy S26" else Build.MODEL
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    // Show over the lock screen and keep the display on: a hidden activity's process moves to the background CPU
+    // set (little cores), where the same model runs about 10x slower.
+    setShowWhenLocked(true)
+    setTurnScreenOn(true)
+    window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+    AsrSession.init(this)
+    recorder = MicRecorder(this)
+    setContentView(buildUi())
+    AsrSession.addListener(onEvent)
+    startFrom(intent)
+  }
+
+  override fun onNewIntent(intent: Intent) {
+    super.onNewIntent(intent)
+    setIntent(intent)
+    if (!busy) startFrom(intent)
+  }
+
+  override fun onResume() {
+    super.onResume()
+    refreshPicker()
+  }
+
+  override fun onDestroy() {
+    AsrSession.removeListener(onEvent)
+    recorder.stop()
+    player.stop()
+    main.removeCallbacksAndMessages(null)
+    // The engine holds gigabytes: free it when the screen goes away for good.
+    if (isFinishing) AsrSession.release()
+    super.onDestroy()
+  }
+
+  // ---- model --------------------------------------------------------------------------------------------------
+
+  /** Picks the model from the launch extras, the last one used, or the first on the phone, and loads it. */
+  private fun startFrom(launch: Intent) {
+    lmBackend = if (launch.getStringExtra(EXTRA_BACKEND) == "gpu") LmBackend.GPU else LmBackend.CPU
+    deviceLine.text = statusLine()
+    extrasPending = launch.getBooleanExtra(EXTRA_AUTOPLAY, false) || launch.getIntExtra(EXTRA_MIC_TEST_MS, 0) > 0
+    val requested = ModelProfile.byId(launch.getStringExtra(EXTRA_MODEL))
+    val saved = ModelProfile.byId(getPreferences(MODE_PRIVATE).getString(PREF_MODEL, null))
+    val choice =
+      listOfNotNull(requested, saved).firstOrNull { AsrSession.isPresent(it) }
+        ?: ModelProfile.ALL.firstOrNull { AsrSession.isPresent(it) }
+    when {
+      choice == null -> showNoModel()
+      requested != null && choice != requested -> {
+        // Shown once the model that is on the phone is ready (the load clears the screen).
+        pendingNotice = AsrEngine.missingBundleMessage(requested, AsrSession.modelDir)
+        selectModel(choice)
+      }
+      else -> selectModel(choice)
+    }
+  }
+
+  /**
+   * Loads [profile] (the picker's tap). Returns the load, or null when the bundle is not on the phone (the screen
+   * then says which file to push where). A model that is already loaded is not loaded again.
+   */
+  fun selectModel(profile: ModelProfile, backend: LmBackend = lmBackend): Future<LoadInfo>? {
+    if (!AsrSession.isPresent(profile)) {
+      refreshPicker()
+      showText(AsrEngine.missingBundleMessage(profile, AsrSession.modelDir))
+      return null
+    }
+    selected = profile
+    lmBackend = backend
+    getPreferences(MODE_PRIVATE).edit().putString(PREF_MODEL, profile.id).apply()
+    refreshPicker()
+    val current = AsrSession.current
+    if (current != null && current.profile == profile && current.lmBackend == backend) {
+      showReady(current)
+      return CompletableFuture.completedFuture(current)
+    }
+    setBusy(true)
+    return AsrSession.load(profile, backend)
+  }
+
+  private fun handle(event: AsrEvent) {
+    when (event) {
+      is AsrEvent.Loading -> {
+        setPill("LOADING", C_IDLE)
+        engineLine.text =
+          String.format(
+            Locale.US,
+            "loading %s (%.2f GB) · LM %s",
+            event.profile.displayName,
+            AsrSession.bundleFile(event.profile).length() / 1e9,
+            backendLabel(event.lmBackend),
+          )
+        clearResult()
+      }
+      is AsrEvent.Loaded -> {
+        setBusy(false)
+        showReady(event.info)
+      }
+      is AsrEvent.LoadFailed -> {
+        setBusy(false)
+        setPill("ERROR", C_LIVE)
+        // A missing file leaves the model loaded before in place.
+        engineLine.text = AsrSession.current?.let { "${it.profile.displayName} still loaded" } ?: "no model loaded"
+        showText(event.message)
+      }
+      is AsrEvent.Transcribing -> setPill("TRANSCRIBING", C_WORK)
+      is AsrEvent.Transcribed -> {
+        show(event.outcome)
+        setBusy(false)
+        if (event.source == SOURCE_MIC) finishMicTest(MicTestResult.Finished(event.outcome))
+        continueAutoplay(event.source)
+      }
+      is AsrEvent.TranscribeFailed -> {
+        setBusy(false)
+        setPill("ERROR", C_LIVE)
+        showText(event.message)
+        if (event.source == SOURCE_MIC) finishMicTest(MicTestResult.Failed(event.message))
+        autoplayIndex = -1
+      }
+      is AsrEvent.Released -> {
+        setPill("RELEASED", C_IDLE)
+        engineLine.text = "${event.profile.displayName} closed"
+        setBusy(busy)
+      }
+    }
+  }
+
+  private fun showReady(info: LoadInfo) {
+    selected = info.profile
+    setPill("READY", C_IDLE)
+    engineLine.text =
+      String.format(
+        Locale.US,
+        "engine load %.2f s · LM %s",
+        info.loadMs / 1000,
+        backendLabel(info.lmBackend),
+      )
+    deviceLine.text = statusLine()
+    refreshPicker()
+    pendingNotice?.let {
+      pendingNotice = null
+      showText(it)
+    }
+    if (extrasPending) {
+      extrasPending = false
+      runLaunchExtras()
+    }
+  }
+
+  private fun showNoModel() {
+    setPill("NO MODEL", C_LIVE)
+    engineLine.text = "no model on this phone"
+    val files = ModelProfile.ALL.joinToString("\n") { "· ${it.fileName}  (${it.hubRepo})" }
+    showText("Push at least one bundle to ${AsrSession.modelDir.path}/ with adb, then reopen the app:\n$files")
+    refreshPicker()
+  }
+
+  // ---- clips --------------------------------------------------------------------------------------------------
+
+  /** A bundled clip: play it through the speaker, then transcribe it. */
+  private fun playClip(index: Int) {
+    if (busy || AsrSession.current == null) return
+    val clip = Clip.ALL[index]
+    val file = AsrSession.clipFile(clip)
+    setBusy(true)
+    clearResult()
+    setPill("● PLAYING", C_LIVE)
+    sourceLine.text = String.format(Locale.US, "clip %s · %.1f s", clip.label, Wav.seconds(file))
+    bar.set(0f, C_LIVE)
+    bar.visibility = View.VISIBLE
+    player.play(
+      file,
+      onProgress = { bar.fraction = it },
+      onDone = { failure ->
+        bar.set(1f, C_IDLE)
+        if (failure != null) {
+          setBusy(false)
+          setPill("ERROR", C_LIVE)
+          showText(failure)
+          autoplayIndex = -1
+        } else {
+          AsrSession.transcribe(file, SOURCE_CLIP + clip.id)
+        }
+      },
+    )
+  }
+
+  private fun runLaunchExtras() {
+    val delay = intent.getIntExtra(EXTRA_DELAY_MS, 3000).toLong()
+    val micTestMs = intent.getIntExtra(EXTRA_MIC_TEST_MS, 0)
+    if (intent.getBooleanExtra(EXTRA_AUTOPLAY, false)) {
+      Log.i(TAG, "AUTOPLAY_START delay_ms=$delay")
+      autoplayIndex = 0
+      main.postDelayed({ playClip(0) }, delay)
+    } else if (micTestMs > 0) {
+      val play = intent.getBooleanExtra(EXTRA_MIC_TEST_PLAY, false)
+      main.postDelayed({ runMicTest(micTestMs.toLong(), play) }, delay)
+    }
+  }
+
+  private fun continueAutoplay(source: String) {
+    if (autoplayIndex < 0 || !source.startsWith(SOURCE_CLIP)) return
+    autoplayIndex++
+    if (autoplayIndex >= Clip.ALL.size) {
+      autoplayIndex = -1
+      Log.i(TAG, "AUTOPLAY_DONE")
+      return
+    }
+    val next = autoplayIndex
+    main.postDelayed({ playClip(next) }, intent.getIntExtra(EXTRA_GAP_MS, 2500).toLong())
+  }
+
+  // ---- microphone ---------------------------------------------------------------------------------------------
+
+  /** Hold to talk: recording starts on press and ends on release (or at 30 s). */
+  @SuppressLint("ClickableViewAccessibility") // the button also takes a click: performClick() on release
+  private fun onMicTouch(view: View, event: MotionEvent): Boolean {
+    when (event.actionMasked) {
+      MotionEvent.ACTION_DOWN -> {
+        if (busy || AsrSession.current == null) return true
+        if (!recorder.hasPermission()) {
+          requestPermissions(arrayOf(Manifest.permission.RECORD_AUDIO), REQUEST_MIC)
+          return true
+        }
+        startRecording(playClip = false)
+      }
+      MotionEvent.ACTION_UP -> {
+        view.performClick()
+        recorder.stop()
+      }
+      MotionEvent.ACTION_CANCEL -> recorder.stop()
+    }
+    return true
+  }
+
+  override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
+    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+    if (requestCode != REQUEST_MIC) return
+    if (grantResults.firstOrNull() == PackageManager.PERMISSION_GRANTED) {
+      showText("Microphone allowed. Hold the button and speak.")
+    } else {
+      setPill("NO MIC", C_LIVE)
+      showText(MicRecorder.PERMISSION_MESSAGE)
+    }
+  }
+
+  /**
+   * The microphone path without touching the screen: record for [durationMs] (playing clip en through the speaker
+   * when [playClip]), then transcribe like the button does. [onFinished] gets the outcome or the failure sentence;
+   * without the permission the sentence comes back at once and nothing is recorded.
+   */
+  fun runMicTest(durationMs: Long, playClip: Boolean, onFinished: ((MicTestResult) -> Unit)? = null) {
+    Log.i(TAG, "MIC_TEST ms=$durationMs play=$playClip")
+    micCallback = onFinished
+    if (!recorder.hasPermission()) {
+      setPill("NO MIC", C_LIVE)
+      showText(MicRecorder.PERMISSION_MESSAGE)
+      finishMicTest(MicTestResult.Failed(MicRecorder.PERMISSION_MESSAGE))
+      return
+    }
+    if (busy || AsrSession.current == null) {
+      finishMicTest(MicTestResult.Failed("The app is busy or no model is loaded."))
+      return
+    }
+    if (!startRecording(playClip)) return
+    main.postDelayed({ recorder.stop() }, durationMs)
+  }
+
+  private fun startRecording(playClip: Boolean): Boolean {
+    val wav = File(cacheDir, "mic.wav")
+    val failure =
+      recorder.start(
+        wav,
+        onProgress = { seconds -> main.post { showRecording(seconds) } },
+        onDone = { result -> main.post { onRecorded(result) } },
+      )
+    if (failure != null) {
+      setPill("ERROR", C_LIVE)
+      showText(failure)
+      finishMicTest(MicTestResult.Failed(failure))
+      return false
+    }
+    setBusy(true)
+    micButton.isEnabled = true
+    micButton.alpha = 1f
+    clearResult()
+    setPill("● LISTENING", C_LIVE)
+    showRecording(0.0)
+    bar.set(0f, C_LIVE)
+    bar.visibility = View.VISIBLE
+    if (playClip) {
+      val clip = AsrSession.clipFile(Clip.ALL[1])
+      main.postDelayed({ player.play(clip, onProgress = {}, onDone = {}) }, MIC_TEST_PLAY_DELAY_MS)
+    }
+    return true
+  }
+
+  private fun showRecording(seconds: Double) {
+    sourceLine.text = String.format(Locale.US, "mic · %.1f s of %d s", seconds, MicRecorder.MAX_SECONDS)
+    bar.fraction = (seconds / MicRecorder.MAX_SECONDS).toFloat()
+    micButton.text = String.format(Locale.US, "Release to transcribe · %.1f s", seconds)
+  }
+
+  private fun onRecorded(result: MicResult) {
+    micButton.text = MIC_LABEL
+    bar.set(1f, C_IDLE)
+    when (result) {
+      is MicResult.Failed -> {
+        setBusy(false)
+        setPill("ERROR", C_LIVE)
+        showText(result.message)
+        finishMicTest(MicTestResult.Failed(result.message))
+      }
+      is MicResult.Recorded -> {
+        Log.i(
+          TAG,
+          String.format(
+            Locale.US,
+            "MIC_RECORDED seconds=%.2f peak_dbfs=%.1f rms_dbfs=%.1f at_limit=%b",
+            result.seconds,
+            result.levels.peakDbfs,
+            result.levels.rmsDbfs,
+            result.stoppedAtLimit,
+          ),
+        )
+        sourceLine.text =
+          String.format(Locale.US, "mic · %.1f s", result.seconds) +
+            if (result.stoppedAtLimit) " · stopped at the ${MicRecorder.MAX_SECONDS} s limit" else ""
+        setBusy(true)
+        AsrSession.transcribe(result.wav, SOURCE_MIC)
+      }
+    }
+  }
+
+  private fun finishMicTest(result: MicTestResult) {
+    val callback = micCallback ?: return
+    micCallback = null
+    callback(result)
+  }
+
+  // ---- screen -------------------------------------------------------------------------------------------------
+
+  private fun show(outcome: TranscribeOutcome) {
+    when (outcome) {
+      is TranscribeOutcome.NoSpeech -> {
+        setPill("NO SPEECH", C_IDLE)
+        body.text = "No speech heard."
+        languageLine.text =
+          String.format(
+            Locale.US,
+            "The recording peaked at %.0f dBFS (RMS %.0f dBFS); the model was not called.",
+            outcome.levels.peakDbfs,
+            outcome.levels.rmsDbfs,
+          )
+        timeLine.text = ""
+      }
+      is TranscribeOutcome.Text -> {
+        val transcript = outcome.transcript
+        val answer = transcript.answer
+        setPill("DONE", C_DONE)
+        body.textLocale = localeFor(answer)
+        body.text = answer.text.ifEmpty { "(no speech in the answer)" }
+        languageLine.text =
+          when {
+            transcript.profile.answerFormat == AnswerFormat.PLAIN -> ""
+            answer.language.isEmpty() -> "detected language: none"
+            else -> "detected language: ${answer.language}"
+          }
+        val numbers =
+          String.format(
+            Locale.US,
+            "transcribe %.2f s / clip %.2f s = RTF %.2f",
+            transcript.sendMs / 1000,
+            transcript.sentSeconds,
+            transcript.rtf,
+          )
+        timeLine.text =
+          SpannableStringBuilder(numbers).apply {
+            setSpan(ForegroundColorSpan(C_TEXT), 0, numbers.length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+            setSpan(StyleSpan(Typeface.BOLD), 0, numbers.length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+          }
+      }
+    }
+  }
+
+  private fun showText(text: String) {
+    body.textLocale = Locale.US
+    body.text = text
+    languageLine.text = ""
+    timeLine.text = ""
+  }
+
+  private fun clearResult() {
+    sourceLine.text = ""
+    body.text = ""
+    languageLine.text = ""
+    timeLine.text = ""
+    bar.visibility = View.INVISIBLE
+  }
+
+  /** The glyph forms of Han characters follow the language the model named, or the script of the text. */
+  private fun localeFor(answer: Answer): Locale =
+    when {
+      answer.language == "Japanese" || answer.text.any { it in '぀'..'ヿ' } -> Locale.JAPANESE
+      answer.language == "Cantonese" -> Locale.TRADITIONAL_CHINESE
+      answer.language == "Chinese" ||
+        answer.text.any { Character.UnicodeScript.of(it.code) == Character.UnicodeScript.HAN } ->
+        Locale.SIMPLIFIED_CHINESE
+      else -> Locale.US
+    }
+
+  private fun refreshPicker() {
+    if (!::pickerRows.isInitialized) return
+    val loaded = AsrSession.current?.profile
+    for ((profile, row) in pickerRows) {
+      val present = AsrSession.isPresent(profile)
+      val bytes = if (present) AsrSession.bundleFile(profile).length() else profile.hubBytes
+      val mark = if (profile == selected) "●  " else "○  "
+      val state =
+        when {
+          !present -> "missing"
+          profile == loaded -> "loaded"
+          else -> "on phone"
+        }
+      val head = mark + profile.displayName
+      val text = String.format(Locale.US, "%s   %.2f GB · %s", head, bytes / 1e9, state)
+      row.text =
+        SpannableStringBuilder(text).apply {
+          setSpan(StyleSpan(Typeface.BOLD), 0, head.length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
+        }
+      row.setTextColor(if (present) C_TEXT else C_SUB)
+      row.background = rounded(if (profile == selected) C_SELECTED else C_BUTTON, C_BUTTON_EDGE)
+      row.isEnabled = !busy
+    }
+  }
+
+  private fun setBusy(on: Boolean) {
+    busy = on
+    val ready = !on && AsrSession.current != null
+    for (button in clipButtons + micButton) {
+      button.isEnabled = ready
+      button.alpha = if (ready) 1f else 0.4f
+    }
+    refreshPicker()
+  }
+
+  private fun setPill(label: String, color: Int) {
+    pill.text = label
+    pill.background = GradientDrawable().apply {
+      cornerRadius = dp(999f)
+      setColor(color)
+    }
+    Log.i(TAG, "STATE ${label.removePrefix("● ").replace(' ', '_')}")
+  }
+
+  private fun statusLine(): String =
+    String.format(
+      Locale.US,
+      "%s · LiteRT-LM %s · LM %s, audio CPU",
+      deviceName,
+      BuildConfig.LITERTLM_VERSION,
+      if (lmBackend == LmBackend.GPU) "GPU" else "CPU",
+    )
+
+  private fun backendLabel(backend: LmBackend): String =
+    if (backend == LmBackend.GPU) "GPU" else "CPU ${AsrEngine.CPU_THREADS} threads"
+
+  private fun buildUi(): View {
+    val side = dp(20f).toInt()
+    val root =
+      LinearLayout(this).apply {
+        orientation = LinearLayout.VERTICAL
+        setBackgroundColor(C_BG)
+        setOnApplyWindowInsetsListener { view, insets ->
+          val bars = insets.getInsets(WindowInsets.Type.systemBars() or WindowInsets.Type.displayCutout())
+          view.setPadding(side + bars.left, dp(14f).toInt() + bars.top, side + bars.right, dp(14f).toInt() + bars.bottom)
+          insets
+        }
+      }
+    val title = label(15f, C_TEXT, bold = true).apply { text = "Speech to text on the phone · LiteRT-LM" }
+    val picker = LinearLayout(this).apply { orientation = LinearLayout.VERTICAL }
+    pickerRows =
+      ModelProfile.ALL.associateWith { profile ->
+        label(14f, C_TEXT).apply {
+          setPadding(dp(14f).toInt(), dp(10f).toInt(), dp(14f).toInt(), dp(10f).toInt())
+          maxLines = 1
+          setOnClickListener { if (!busy) selectModel(profile) }
+          picker.addView(this, layoutParams(top = 8f))
+        }
+      }
+    pill =
+      label(13f, C_TEXT, bold = true).apply {
+        letterSpacing = 0.08f
+        gravity = Gravity.CENTER_VERTICAL
+        setPadding(dp(12f).toInt(), 0, dp(12f).toInt(), 0)
+      }
+    engineLine = label(14f, C_SUB)
+    sourceLine = label(17f, C_SUB)
+    bar = PlayBar(this, C_BUTTON_EDGE).apply { visibility = View.INVISIBLE }
+    body = label(24f, C_TEXT).apply { setLineSpacing(0f, 1.1f) }
+    languageLine = label(17f, C_TEXT)
+    timeLine = label(15f, C_SUB)
+    deviceLine = label(13f, C_SUB)
+    val attribution = label(13f, C_SUB).apply { text = ATTRIBUTION }
+
+    val result =
+      LinearLayout(this).apply {
+        orientation = LinearLayout.VERTICAL
+        addView(sourceLine, layoutParams(top = 14f))
+        addView(
+          bar,
+          LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, dp(6f).toInt()).apply {
+            topMargin = dp(10f).toInt()
+          },
+        )
+        addView(body, layoutParams(top = 14f))
+        addView(languageLine, layoutParams(top = 14f))
+      }
+    val scroll =
+      ScrollView(this).apply {
+        isVerticalScrollBarEnabled = false
+        addView(result)
+      }
+    val clipRow = LinearLayout(this).apply { orientation = LinearLayout.HORIZONTAL }
+    clipButtons =
+      Clip.ALL.mapIndexed { index, clip ->
+        val seconds = Wav.seconds(AsrSession.clipFile(clip))
+        button(String.format(Locale.US, "%s · %.1f s", clip.label, seconds)) { playClip(index) }
+          .also {
+            clipRow.addView(
+              it,
+              LinearLayout.LayoutParams(0, dp(52f).toInt(), 1f).apply {
+                if (index > 0) marginStart = dp(10f).toInt()
+              },
+            )
+          }
+      }
+    micButton = button(MIC_LABEL) {}.apply { setOnTouchListener { view, event -> onMicTouch(view, event) } }
+    setBusy(false)
+
+    root.addView(title)
+    root.addView(picker, layoutParams(top = 4f))
+    root.addView(
+      pill,
+      LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, dp(28f).toInt()).apply {
+        topMargin = dp(14f).toInt()
+      },
+    )
+    root.addView(engineLine, layoutParams(top = 6f))
+    root.addView(scroll, LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, 0, 1f))
+    root.addView(clipRow, layoutParams(top = 10f))
+    root.addView(
+      micButton,
+      LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, dp(64f).toInt()).apply {
+        topMargin = dp(10f).toInt()
+      },
+    )
+    // Footer: the measured seconds, then device, runtime and backend, then the clips' source.
+    root.addView(timeLine, layoutParams(top = 12f))
+    root.addView(deviceLine, layoutParams(top = 4f))
+    root.addView(attribution, layoutParams(top = 2f))
+    return root
+  }
+
+  private fun layoutParams(top: Float) =
+    LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT).apply {
+      topMargin = dp(top).toInt()
+    }
+
+  private fun label(sizeSp: Float, color: Int, bold: Boolean = false) =
+    TextView(this).apply {
+      setTextSize(TypedValue.COMPLEX_UNIT_SP, sizeSp)
+      setTextColor(color)
+      if (bold) typeface = Typeface.create(Typeface.DEFAULT, Typeface.BOLD)
+    }
+
+  private fun button(text: String, onClick: () -> Unit) =
+    label(16f, C_TEXT, bold = true).apply {
+      this.text = text
+      gravity = Gravity.CENTER
+      background = rounded(C_BUTTON, C_BUTTON_EDGE)
+      setOnClickListener { onClick() }
+    }
+
+  private fun rounded(fill: Int, edge: Int) =
+    GradientDrawable().apply {
+      cornerRadius = dp(14f)
+      setColor(fill)
+      setStroke(dp(1f).toInt(), edge)
+    }
+
+  private fun dp(value: Float) = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, value, resources.displayMetrics)
+
+  companion object {
+    private const val TAG = "AsrLitertlm"
+    const val EXTRA_MODEL = "model"
+    const val EXTRA_BACKEND = "backend"
+    const val EXTRA_AUTOPLAY = "autoplay"
+    const val EXTRA_DELAY_MS = "delay_ms"
+    const val EXTRA_GAP_MS = "gap_ms"
+    const val EXTRA_MIC_TEST_MS = "mic_test_ms"
+    const val EXTRA_MIC_TEST_PLAY = "mic_test_play"
+    const val SOURCE_MIC = "mic"
+    const val SOURCE_CLIP = "clip:"
+    private const val PREF_MODEL = "model"
+    private const val REQUEST_MIC = 1
+    private const val MIC_TEST_PLAY_DELAY_MS = 500L
+    private const val MIC_LABEL = "Hold to talk (up to 30 s)"
+    // The clips are FLEURS recordings with one linear gain each: CC BY 4.0 asks to say so.
+    private const val ATTRIBUTION = "clips: FLEURS #1698, CC BY 4.0, level-normalized"
+    private const val C_BG = 0xFF0E1116.toInt()
+    private const val C_IDLE = 0xFF5F6368.toInt()
+    private const val C_LIVE = 0xFFE53935.toInt()
+    private const val C_WORK = 0xFF1565C0.toInt()
+    private const val C_DONE = 0xFF2E7D32.toInt()
+    private const val C_TEXT = 0xFFE6E8EB.toInt()
+    private const val C_SUB = 0xFF8A919C.toInt()
+    private const val C_BUTTON = 0xFF1A1F27.toInt()
+    private const val C_SELECTED = 0xFF1E3A5F.toInt()
+    private const val C_BUTTON_EDGE = 0xFF2C333D.toInt()
+  }
+}

android/app/src/main/kotlin/com/asrlitertlm/MicRecorder.kt

@@ -0,0 +1,123 @@
+package com.asrlitertlm
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.pm.PackageManager
+import android.media.AudioFormat
+import android.media.AudioRecord
+import android.media.MediaRecorder
+import java.io.ByteArrayOutputStream
+import java.io.File
+import kotlin.concurrent.thread
+
+/** The end of one recording. */
+sealed interface MicResult {
+  /** A wav of 16 kHz mono 16-bit audio. [stoppedAtLimit] is true when the 30 s limit ended it. */
+  data class Recorded(val wav: File, val seconds: Double, val levels: Wav.Levels, val stoppedAtLimit: Boolean) :
+    MicResult
+
+  /** A sentence for the screen. */
+  data class Failed(val message: String) : MicResult
+}
+
+/**
+ * Records 16 kHz mono 16-bit audio (what the three models take) from the microphone, on its own thread, until
+ * [stop] is called or [MAX_SECONDS] have been recorded.
+ */
+class MicRecorder(private val context: Context) {
+  @Volatile private var stopRequested = false
+
+  @Volatile
+  var isRecording = false
+    private set
+
+  fun hasPermission(): Boolean =
+    context.checkSelfPermission(Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
+
+  /**
+   * Starts a recording into [output]. Returns a failure sentence at once (and records nothing) when the microphone
+   * permission is missing or a recording is running; otherwise returns null, reports the seconds recorded so far to
+   * [onProgress] and the result to [onDone], both on the recording thread.
+   */
+  fun start(output: File, onProgress: (Double) -> Unit, onDone: (MicResult) -> Unit): String? {
+    if (!hasPermission()) return PERMISSION_MESSAGE
+    if (isRecording) return "A recording is already running."
+    stopRequested = false
+    isRecording = true
+    thread(name = "mic-recorder") {
+      val result =
+        try {
+          record(output, onProgress)
+        } catch (e: SecurityException) {
+          MicResult.Failed(PERMISSION_MESSAGE)
+        } catch (e: RuntimeException) {
+          MicResult.Failed("Recording failed: ${e.message ?: e}")
+        }
+      isRecording = false
+      onDone(result)
+    }
+    return null
+  }
+
+  /** Ends the recording; [start]'s onDone follows. */
+  fun stop() {
+    stopRequested = true
+  }
+
+  @SuppressLint("MissingPermission") // checked in start(); a revocation in between ends in SecurityException
+  private fun record(output: File, onProgress: (Double) -> Unit): MicResult {
+    val minBuffer =
+      AudioRecord.getMinBufferSize(SAMPLE_RATE, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT)
+    if (minBuffer <= 0) return MicResult.Failed("This phone cannot record 16 kHz mono audio.")
+    val recorder =
+      AudioRecord(
+        MediaRecorder.AudioSource.VOICE_RECOGNITION,
+        SAMPLE_RATE,
+        AudioFormat.CHANNEL_IN_MONO,
+        AudioFormat.ENCODING_PCM_16BIT,
+        maxOf(minBuffer, SAMPLE_RATE),
+      )
+    if (recorder.state != AudioRecord.STATE_INITIALIZED) {
+      recorder.release()
+      return MicResult.Failed("The microphone could not be opened. Another app may be using it.")
+    }
+    val pcm = ByteArrayOutputStream()
+    val maxBytes = SAMPLE_RATE * BYTES_PER_SAMPLE * MAX_SECONDS
+    try {
+      recorder.startRecording()
+      if (recorder.recordingState != AudioRecord.RECORDSTATE_RECORDING) {
+        return MicResult.Failed("The microphone did not start. Another app may be using it.")
+      }
+      val buffer = ByteArray(SAMPLE_RATE / 10 * BYTES_PER_SAMPLE) // 100 ms
+      while (!stopRequested && pcm.size() < maxBytes) {
+        val count = recorder.read(buffer, 0, minOf(buffer.size, maxBytes - pcm.size()))
+        if (count < 0) return MicResult.Failed("Recording failed (AudioRecord error $count).")
+        pcm.write(buffer, 0, count)
+        onProgress(pcm.size().toDouble() / (SAMPLE_RATE * BYTES_PER_SAMPLE))
+      }
+    } finally {
+      runCatching { recorder.stop() }
+      recorder.release()
+    }
+    val bytes = pcm.toByteArray()
+    if (bytes.isEmpty()) return MicResult.Failed("No audio was recorded.")
+    Wav.writeMono16(output, bytes, SAMPLE_RATE)
+    return MicResult.Recorded(
+      wav = output,
+      seconds = bytes.size.toDouble() / (SAMPLE_RATE * BYTES_PER_SAMPLE),
+      levels = Wav.levels(bytes),
+      stoppedAtLimit = bytes.size >= maxBytes,
+    )
+  }
+
+  companion object {
+    const val SAMPLE_RATE = 16_000
+    const val MAX_SECONDS = 30
+    private const val BYTES_PER_SAMPLE = 2
+
+    const val PERMISSION_MESSAGE =
+      "Microphone permission is off, so the app cannot record. The three clips still work. To use the " +
+        "microphone, allow it in Settings > Apps > ASR LiteRT-LM > Permissions."
+  }
+}

android/app/src/main/kotlin/com/asrlitertlm/ModelProfile.kt

@@ -0,0 +1,108 @@
+package com.asrlitertlm
+
+/** How a model writes its answer. */
+enum class AnswerFormat {
+  /** Qwen3-ASR and its fine-tunes: `language <name><asr_text><transcript>`. */
+  LANGUAGE_TAGGED,
+
+  /** Fun-ASR-Nano: the transcript alone. */
+  PLAIN,
+}
+
+/** A transcript, split into the language the model named (empty when it named none) and the text. */
+data class Answer(val language: String, val text: String)
+
+/**
+ * One bundle's contract with this app. All three bundles go through the same calls: one Engine, a new Conversation per
+ * clip, one user message holding only the audio (each bundle's own template adds the rest: Fun-ASR's default
+ * instruction `语音转写：`, Qwen3-ASR's audio markers), greedy sampling and [maxOutputTokens]. Only the shape of the
+ * answer differs ([answerFormat]).
+ */
+data class ModelProfile(
+  /** Stable key for launch extras and the device check. */
+  val id: String,
+  val displayName: String,
+  /** The file name the app looks for in its external files directory. */
+  val fileName: String,
+  val hubRepo: String,
+  /** Size of the file on the Hub, shown before the file is on the phone. */
+  val hubBytes: Long,
+  val license: String,
+  val languages: String,
+  val answerFormat: AnswerFormat,
+  val maxOutputTokens: Int = 512,
+) {
+  /** Splits a raw answer into language and text. */
+  fun parse(raw: String): Answer =
+    when (answerFormat) {
+      AnswerFormat.PLAIN -> Answer(language = "", text = raw.trim())
+      AnswerFormat.LANGUAGE_TAGGED -> parseTagged(raw)
+    }
+
+  companion object {
+    private const val ASR_TEXT = "<asr_text>"
+    private const val LANGUAGE_PREFIX = "language "
+
+    val QWEN3_ASR_1_7B =
+      ModelProfile(
+        id = "qwen3-asr-1.7b",
+        displayName = "Qwen3-ASR-1.7B",
+        fileName = "Qwen3-ASR-1.7B.litertlm",
+        hubRepo = "litert-community/Qwen3-ASR-1.7B",
+        hubBytes = 2_693_064_192L,
+        license = "Apache-2.0",
+        languages = "30 languages",
+        answerFormat = AnswerFormat.LANGUAGE_TAGGED,
+      )
+
+    val FUN_ASR_NANO_2512 =
+      ModelProfile(
+        id = "fun-asr-nano-2512",
+        displayName = "Fun-ASR-Nano-2512",
+        fileName = "Fun-ASR-Nano-2512.litertlm",
+        hubRepo = "litert-community/Fun-ASR-Nano-2512",
+        hubBytes = 1_255_894_736L,
+        license = "Apache-2.0",
+        languages = "zh / en / ja",
+        answerFormat = AnswerFormat.PLAIN,
+      )
+
+    val CONFUCIUS4_R2T2 =
+      ModelProfile(
+        id = "confucius4-r2t2",
+        displayName = "Confucius4-R2T2",
+        fileName = "Confucius4-R2T2.litertlm",
+        hubRepo = "mlboydaisuke/Confucius4-R2T2-LiteRT",
+        hubBytes = 2_693_064_192L,
+        license = "NetEase Youdao Model Use License",
+        languages = "zh / en (Qwen3-ASR fine-tune)",
+        answerFormat = AnswerFormat.LANGUAGE_TAGGED,
+      )
+
+    /** The picker's rows, in screen order. */
+    val ALL = listOf(QWEN3_ASR_1_7B, FUN_ASR_NANO_2512, CONFUCIUS4_R2T2)
+
+    fun byId(id: String?): ModelProfile? = ALL.firstOrNull { it.id == id }
+
+    /**
+     * `language <name><asr_text><text>` -> (name, text), as qwen-asr's parse_asr_output does without a forced
+     * language; "language None" gives an empty name, and an answer without the tag is all text.
+     */
+    private fun parseTagged(raw: String): Answer {
+      val answer = raw.trim()
+      val tag = answer.indexOf(ASR_TEXT)
+      if (tag < 0) return Answer(language = "", text = answer)
+      val meta = answer.substring(0, tag)
+      val name =
+        meta
+          .lineSequence()
+          .map { it.trim() }
+          .firstOrNull { it.lowercase().startsWith(LANGUAGE_PREFIX) }
+          ?.substring(LANGUAGE_PREFIX.length)
+          ?.trim()
+          .orEmpty()
+      val language = if (name.equals("None", ignoreCase = true)) "" else name
+      return Answer(language = language, text = answer.substring(tag + ASR_TEXT.length).trim())
+    }
+  }
+}

android/app/src/main/kotlin/com/asrlitertlm/PlayBar.kt

@@ -0,0 +1,35 @@
+package com.asrlitertlm
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.view.View
+
+/** A thin rounded bar: the share of a clip played, or of the 30 s recording limit used. */
+class PlayBar(context: Context, trackColor: Int) : View(context) {
+  private val trackPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { color = trackColor }
+  private val fillPaint = Paint(Paint.ANTI_ALIAS_FLAG)
+
+  var fraction = 0f
+    set(value) {
+      if (value != field) {
+        field = value
+        invalidate()
+      }
+    }
+
+  fun set(fraction: Float, fillColor: Int) {
+    fillPaint.color = fillColor
+    this.fraction = fraction
+    invalidate()
+  }
+
+  override fun onDraw(canvas: Canvas) {
+    val height = height.toFloat()
+    val radius = height / 2
+    canvas.drawRoundRect(0f, 0f, width.toFloat(), height, radius, radius, trackPaint)
+    if (fraction > 0f) {
+      canvas.drawRoundRect(0f, 0f, maxOf(height, width * fraction), height, radius, radius, fillPaint)
+    }
+  }
+}

android/app/src/main/kotlin/com/asrlitertlm/TextMatch.kt

@@ -0,0 +1,64 @@
+package com.asrlitertlm
+
+import java.text.Normalizer
+
+/**
+ * Transcript comparison for the device check, the way the model cards score: NFKC, lowercase, every punctuation,
+ * separator and whitespace character removed, then the character error rate against the expected text.
+ */
+object TextMatch {
+  fun normalize(text: String): String {
+    val folded = Normalizer.normalize(text, Normalizer.Form.NFKC).lowercase()
+    val out = StringBuilder()
+    var i = 0
+    while (i < folded.length) {
+      val codePoint = folded.codePointAt(i)
+      if (!isDropped(codePoint)) out.appendCodePoint(codePoint)
+      i += Character.charCount(codePoint)
+    }
+    return out.toString()
+  }
+
+  /** Edit distance between the normalized texts over the normalized [expected] length (code points). */
+  fun cer(expected: String, actual: String): Double {
+    val reference = normalize(expected).codePoints().toArray()
+    val hypothesis = normalize(actual).codePoints().toArray()
+    if (reference.isEmpty()) return if (hypothesis.isEmpty()) 0.0 else 1.0
+    return editDistance(reference, hypothesis).toDouble() / reference.size
+  }
+
+  /** True when the two texts are equal after [normalize]. */
+  fun matches(expected: String, actual: String): Boolean = normalize(expected) == normalize(actual)
+
+  private fun isDropped(codePoint: Int): Boolean =
+    Character.isWhitespace(codePoint) ||
+      when (Character.getType(codePoint).toByte()) {
+        Character.CONNECTOR_PUNCTUATION,
+        Character.DASH_PUNCTUATION,
+        Character.START_PUNCTUATION,
+        Character.END_PUNCTUATION,
+        Character.INITIAL_QUOTE_PUNCTUATION,
+        Character.FINAL_QUOTE_PUNCTUATION,
+        Character.OTHER_PUNCTUATION,
+        Character.SPACE_SEPARATOR,
+        Character.LINE_SEPARATOR,
+        Character.PARAGRAPH_SEPARATOR -> true
+        else -> false
+      }
+
+  private fun editDistance(a: IntArray, b: IntArray): Int {
+    var previous = IntArray(b.size + 1) { it }
+    var current = IntArray(b.size + 1)
+    for (i in 1..a.size) {
+      current[0] = i
+      for (j in 1..b.size) {
+        val substitution = previous[j - 1] + if (a[i - 1] == b[j - 1]) 0 else 1
+        current[j] = minOf(substitution, previous[j] + 1, current[j - 1] + 1)
+      }
+      val swap = previous
+      previous = current
+      current = swap
+    }
+    return previous[b.size]
+  }
+}

android/app/src/main/kotlin/com/asrlitertlm/Wav.kt

@@ -0,0 +1,140 @@
+package com.asrlitertlm
+
+import java.io.File
+import java.io.RandomAccessFile
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.math.abs
+import kotlin.math.log10
+import kotlin.math.max
+
+/**
+ * Minimal RIFF/WAVE helpers: the length and the samples of a wav (walks the chunks; the bundled clips carry a LIST
+ * chunk), a 16-bit mono writer for the microphone, a trimmed copy for clips longer than one model window, and the
+ * level of a recording.
+ */
+object Wav {
+  /** 16-bit PCM samples of a wav, interleaved when [channels] > 1. */
+  class Pcm(val data: ByteArray, val sampleRate: Int, val channels: Int) {
+    /** Frames (samples per channel). */
+    val frames: Int
+      get() = data.size / (2 * channels)
+
+    val seconds: Double
+      get() = frames.toDouble() / sampleRate
+  }
+
+  /** Peak and RMS of a recording in dBFS (-120 for digital silence). */
+  data class Levels(val peakDbfs: Double, val rmsDbfs: Double)
+
+  private class Info(
+    val sampleRate: Int,
+    val channels: Int,
+    val bits: Int,
+    val byteRate: Int,
+    val dataSize: Long,
+    val data: ByteArray?,
+  )
+
+  private fun read(file: File, withData: Boolean): Info {
+    RandomAccessFile(file, "r").use { f ->
+      val head = ByteArray(12).also { f.readFully(it) }
+      require(String(head, 0, 4) == "RIFF" && String(head, 8, 4) == "WAVE") { "not a wav: $file" }
+      var fmt: ByteBuffer? = null
+      while (f.filePointer + 8 <= f.length()) {
+        val header = ByteArray(8).also { f.readFully(it) }
+        val id = String(header, 0, 4)
+        val size = ByteBuffer.wrap(header, 4, 4).order(ByteOrder.LITTLE_ENDIAN).int.toLong() and 0xffffffffL
+        when (id) {
+          "fmt " -> {
+            fmt = ByteBuffer.wrap(ByteArray(size.toInt()).also { f.readFully(it) }).order(ByteOrder.LITTLE_ENDIAN)
+            if (size % 2 == 1L) f.skipBytes(1)
+          }
+          "data" -> {
+            val format = requireNotNull(fmt) { "data before fmt in $file" }
+            // A recorder that never patched the header reports 0 or 0xFFFFFFFF: take what the file holds.
+            val available = f.length() - f.filePointer
+            val length = if (size == 0L || size > available) available else size
+            val data = if (withData) ByteArray(length.toInt()).also { f.readFully(it) } else null
+            return Info(
+              sampleRate = format.getInt(4),
+              channels = format.getShort(2).toInt(),
+              bits = format.getShort(14).toInt(),
+              byteRate = format.getInt(8),
+              dataSize = length,
+              data = data,
+            )
+          }
+          else -> f.seek(f.filePointer + size + (size % 2))
+        }
+      }
+    }
+    error("no data chunk in $file")
+  }
+
+  /** The length of a wav in seconds, from its header. */
+  fun seconds(file: File): Double = read(file, withData = false).let { it.dataSize.toDouble() / it.byteRate }
+
+  /** The samples of a 16-bit PCM wav. */
+  fun pcm16(file: File): Pcm =
+    read(file, withData = true).let {
+      require(it.bits == 16) { "not 16-bit PCM: $file" }
+      Pcm(it.data!!, it.sampleRate, it.channels)
+    }
+
+  /** Writes 16-bit mono PCM as a canonical 44-byte-header wav. */
+  fun writeMono16(file: File, pcm: ByteArray, sampleRate: Int) {
+    val header =
+      ByteBuffer.allocate(44).order(ByteOrder.LITTLE_ENDIAN).apply {
+        put("RIFF".toByteArray())
+        putInt(36 + pcm.size)
+        put("WAVE".toByteArray())
+        put("fmt ".toByteArray())
+        putInt(16)
+        putShort(1)
+        putShort(1)
+        putInt(sampleRate)
+        putInt(sampleRate * 2)
+        putShort(2)
+        putShort(16)
+        put("data".toByteArray())
+        putInt(pcm.size)
+      }
+    file.outputStream().use {
+      it.write(header.array())
+      it.write(pcm)
+    }
+  }
+
+  /**
+   * Returns [source] when it is at most [maxSeconds] long; otherwise writes its first [maxSeconds] (mono, 16-bit)
+   * to [target] and returns that. The models read one window of about 30 s per message.
+   */
+  fun trimmed(source: File, maxSeconds: Double, target: File): File {
+    if (seconds(source) <= maxSeconds) return source
+    val pcm = pcm16(source)
+    require(pcm.channels == 1) { "only mono clips are trimmed: $source" }
+    val keepBytes = (maxSeconds * pcm.sampleRate).toInt() * 2
+    writeMono16(target, pcm.data.copyOf(keepBytes), pcm.sampleRate)
+    return target
+  }
+
+  /** Peak and RMS of 16-bit little-endian PCM. */
+  fun levels(pcm: ByteArray): Levels {
+    val samples = ByteBuffer.wrap(pcm).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer()
+    var peak = 0
+    var sumOfSquares = 0.0
+    for (k in 0 until samples.limit()) {
+      val value = samples.get(k).toInt()
+      peak = max(peak, abs(value))
+      sumOfSquares += value.toDouble() * value
+    }
+    val count = max(samples.limit(), 1)
+    return Levels(peakDbfs = toDbfs(peak.toDouble()), rmsDbfs = toDbfs(Math.sqrt(sumOfSquares / count)))
+  }
+
+  private fun toDbfs(amplitude: Double): Double =
+    if (amplitude <= 0.0) SILENCE_DBFS else max(SILENCE_DBFS, 20 * log10(amplitude / 32768.0))
+
+  private const val SILENCE_DBFS = -120.0
+}

android/app/src/main/res/raw/fleurs_cmn_1698.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f72a74b2b83aee568941fe6bd174309a5a54ac9d2dc0b698f6587a8b29aeffd2
+size 311084

android/app/src/main/res/raw/fleurs_en_1698.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a696132b9f79f7936d470a6dc6fdb19ce009b4701165afe9097fa970923dff76
+size 205484

android/app/src/main/res/raw/fleurs_ja_1698.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1235eb34a774a5b52e2032e0a344765cbc7decadad943d8ae77872c482599ba7
+size 353324

android/app/src/main/res/values/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">ASR LiteRT-LM</string>
+</resources>

android/app/src/main/res/values/themes.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="Theme.AsrLitertlm" parent="@android:style/Theme.DeviceDefault.NoActionBar">
+        <item name="android:windowBackground">@color/bg</item>
+        <item name="android:colorBackground">@color/bg</item>
+        <item name="android:statusBarColor">@color/bg</item>
+        <item name="android:navigationBarColor">@color/bg</item>
+        <item name="android:windowLightStatusBar">false</item>
+        <!-- A plain dark launch screen: no default launcher icon on the system splash. -->
+        <item name="android:windowSplashScreenBackground">@color/bg</item>
+        <item name="android:windowSplashScreenAnimatedIcon">@android:color/transparent</item>
+    </style>
+
+    <color name="bg">#0E1116</color>
+</resources>

android/app/src/test/kotlin/com/asrlitertlm/AsrLogicTest.kt

@@ -0,0 +1,104 @@
+package com.asrlitertlm
+
+import java.io.File
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.math.sin
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+/** The parts of the app that run without a phone: answer parsing, transcript matching and the wav helpers. */
+class AsrLogicTest {
+  @get:Rule val folder = TemporaryFolder()
+
+  @Test
+  fun taggedAnswerSplitsLanguageAndText() {
+    val answer =
+      ModelProfile.QWEN3_ASR_1_7B.parse(
+        "language English<asr_text>Everything in the universe is made of matter."
+      )
+    assertEquals(Answer("English", "Everything in the universe is made of matter."), answer)
+  }
+
+  @Test
+  fun taggedAnswerWithLanguageNoneHasNoLanguage() {
+    assertEquals(Answer("", "hello"), ModelProfile.CONFUCIUS4_R2T2.parse("language None<asr_text>hello"))
+  }
+
+  @Test
+  fun answerWithoutTagIsAllText() {
+    assertEquals(Answer("", "宇宙中的一切"), ModelProfile.QWEN3_ASR_1_7B.parse("  宇宙中的一切 "))
+  }
+
+  @Test
+  fun plainAnswerKeepsTheTagLikeText() {
+    // Fun-ASR writes the transcript alone; nothing in it is read as a language tag.
+    assertEquals(
+      Answer("", "language English<asr_text>x"),
+      ModelProfile.FUN_ASR_NANO_2512.parse("language English<asr_text>x"),
+    )
+  }
+
+  @Test
+  fun normalizationDropsPunctuationSpaceAndCase() {
+    assertTrue(
+      TextMatch.matches(
+        "Everything in the universe is made of matter. All matter is made of tiny particles called atoms.",
+        "everything in the Universe is made of matter, all matter is made of tiny particles called atoms",
+      )
+    )
+    assertTrue(TextMatch.matches("宇宙中的一切都由物质构成，而所有的物质", "宇宙中的一切都由物质构成 而所有的物质。"))
+    assertTrue(TextMatch.matches("ＡＢＣ１２３", "abc123")) // NFKC folds full-width forms
+  }
+
+  @Test
+  fun cerCountsCharacterEdits() {
+    // 微小粒子 -> 微小颗粒: two substitutions over 32 characters (punctuation removed).
+    val reference = "宇宙中的一切都由物质构成，而所有的物质都由被称为原子的微小粒子组成。"
+    val hypothesis = "宇宙中的一切都由物质构成，而所有的物质都由被称为原子的微小颗粒组成。"
+    assertEquals(2.0 / 32.0, TextMatch.cer(reference, hypothesis), 1e-9)
+    assertEquals(0.0, TextMatch.cer(reference, reference), 0.0)
+    assertEquals(1.0, TextMatch.cer(reference, ""), 0.0)
+  }
+
+  @Test
+  fun shortWavIsSentAsIs() {
+    val wav = tone(seconds = 2.0)
+    assertSame(wav, Wav.trimmed(wav, 30.0, folder.newFile("cut.wav")))
+  }
+
+  @Test
+  fun longWavIsCutAtThirtySeconds() {
+    val wav = tone(seconds = 33.6)
+    assertEquals(33.6, Wav.seconds(wav), 1e-6)
+    val cut = Wav.trimmed(wav, 30.0, folder.newFile("cut.wav"))
+    assertEquals(30.0, Wav.seconds(cut), 1e-6)
+    val original = Wav.pcm16(wav).data
+    val kept = Wav.pcm16(cut).data
+    assertTrue(kept.contentEquals(original.copyOf(kept.size)))
+  }
+
+  @Test
+  fun silenceAndToneLevels() {
+    val silence = Wav.levels(ByteArray(32_000))
+    assertEquals(-120.0, silence.rmsDbfs, 0.0)
+    assertTrue(silence.rmsDbfs < AsrSession.NO_SPEECH_RMS_DBFS)
+    val tone = Wav.levels(Wav.pcm16(tone(seconds = 1.0)).data)
+    // A sine at half scale: peak about -6 dBFS, RMS about -9 dBFS.
+    assertEquals(-6.0, tone.peakDbfs, 0.1)
+    assertEquals(-9.0, tone.rmsDbfs, 0.1)
+    assertFalse(tone.rmsDbfs < AsrSession.NO_SPEECH_RMS_DBFS)
+  }
+
+  private fun tone(seconds: Double, rate: Int = 16_000): File {
+    val samples = (seconds * rate).toInt()
+    val pcm = ByteBuffer.allocate(samples * 2).order(ByteOrder.LITTLE_ENDIAN)
+    for (i in 0 until samples) pcm.putShort((16384 * sin(2 * Math.PI * 440 * i / rate)).toInt().toShort())
+    return folder.newFile().also { Wav.writeMono16(it, pcm.array(), rate) }
+  }
+}

android/build.gradle.kts

@@ -0,0 +1,9 @@
+// AGP 9 has Kotlin built in; do not apply org.jetbrains.kotlin.android.
+// litertlm-android 0.17.1 ships Kotlin 2.4 metadata. The Kotlin Gradle plugin that AGP 9.3.1 brings (2.2.10) reads
+// metadata up to 2.3 only, so the build classpath gets KGP 2.4.0, which the built-in Kotlin then uses.
+buildscript {
+  repositories { mavenCentral() }
+  dependencies { classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:2.4.0") }
+}
+
+plugins { id("com.android.application") version "9.3.1" apply false }

android/gradle.properties

@@ -0,0 +1,7 @@
+org.gradle.jvmargs=-Xmx4g -Dfile.encoding=UTF-8
+android.useAndroidX=true
+kotlin.code.style=official
+# In-process Kotlin compilation: the daemon writes under ~/Library, which sandboxed builds cannot.
+kotlin.compiler.execution.strategy=in-process
+# The LiteRT-LM runtime the three model cards' Kotlin examples were run with; shown on screen as the runtime version.
+litertlmVersion=0.17.1

android/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.7.0-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

android/gradlew

@@ -0,0 +1,248 @@
+#!/bin/sh
+
+#
+# Copyright © 2015 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   gradlew start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh gradlew
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

android/settings.gradle.kts

@@ -0,0 +1,20 @@
+pluginManagement {
+  repositories {
+    google()
+    mavenCentral()
+    gradlePluginPortal()
+  }
+}
+
+dependencyResolutionManagement {
+  repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+  // The LiteRT-LM AARs live on Google Maven.
+  repositories {
+    google()
+    mavenCentral()
+  }
+}
+
+rootProject.name = "asr-litertlm"
+
+include(":app")