@mentra/bluetooth-sdk 0.1.8 → 0.1.10

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/SGCManager.kt

@@ -1,5 +1,7 @@
 package com.mentra.bluetoothsdk.sgcs
 
+import com.mentra.bluetoothsdk.BluetoothSdkDefaults
+import com.mentra.bluetoothsdk.Bridge
 import com.mentra.bluetoothsdk.DeviceStore
 import com.mentra.bluetoothsdk.utils.ConnTypes
 
@@ -21,6 +23,7 @@ abstract class SGCManager {
             authToken: String?,
             compress: String?,
             flash: Boolean,
+            save: Boolean,
             sound: Boolean,
             exposureTimeNs: Long?,
             iso: Int?,
@@ -29,6 +32,26 @@ abstract class SGCManager {
     abstract fun stopStream()
     abstract fun sendStreamKeepAlive(message: MutableMap<String, Any>)
     abstract fun startVideoRecording(requestId: String, save: Boolean, flash: Boolean, sound: Boolean)
+
+    /**
+     * Start video recording with optional per-recording resolution/fps. A width,
+     * height, or fps of 0 means "use the device's saved button-video default".
+     * The base implementation ignores the settings and delegates to the default
+     * recording path; devices that support custom settings (e.g. Mentra Live)
+     * override this.
+     */
+    open fun startVideoRecording(
+        requestId: String,
+        save: Boolean,
+        flash: Boolean,
+        sound: Boolean,
+        width: Int,
+        height: Int,
+        fps: Int,
+    ) {
+        startVideoRecording(requestId, save, flash, sound)
+    }
+
     abstract fun stopVideoRecording(requestId: String)
 
     // Button Settings
@@ -43,7 +66,17 @@ abstract class SGCManager {
     abstract fun clearDisplay()
     abstract fun sendTextWall(text: String)
     abstract fun sendDoubleTextWall(top: String, bottom: String)
-    abstract fun displayBitmap(base64ImageData: String): Boolean
+    /**
+     * Display a bitmap. Optional [x]/[y]/[width]/[height] position and size the target
+     * container (used by G2; other SGCs ignore positioning and render the bitmap as before).
+     */
+    abstract fun displayBitmap(
+            base64ImageData: String,
+            x: Int? = null,
+            y: Int? = null,
+            width: Int? = null,
+            height: Int? = null
+    ): Boolean
     abstract fun showDashboard()
     abstract fun setDashboardPosition(height: Int, depth: Int)
 
@@ -62,6 +95,15 @@ abstract class SGCManager {
     // Dashboard Menu (default no-op — only G2 supports this)
     open fun setDashboardMenu(items: List<Map<String, Any>>) {}
 
+    // Calendar Events (default no-op — only G2 supports this)
+    open fun sendCalendarEvents(events: List<Map<String, Any>>) {}
+
+    // Dashboard display settings (default no-op — only G2 supports this)
+    open fun sendDashboardDisplaySettings() {}
+
+    // Notification Panel (default no-op — only G2 supports this)
+    open fun showNotificationsPanel() {}
+
     // Controller bridging (default no-op — only G2 supports pairing with a ring controller)
     open fun connectController() {}
     open fun disconnectController() {}
@@ -101,6 +143,11 @@ abstract class SGCManager {
     abstract fun forgetWifiNetwork(ssid: String)
     abstract fun sendHotspotState(enabled: Boolean)
 
+    /** Set glasses system clock (Mentra Live only; no-op on other devices). */
+    open fun sendSetSystemTime(timestampMs: Long) {
+        Bridge.log("SGC: sendSetSystemTime not supported on $type")
+    }
+
     // User Context (for crash reporting)
     abstract fun sendUserEmailToGlasses(email: String)
 
@@ -114,6 +161,9 @@ abstract class SGCManager {
     // Voice Activity Detection
     open fun sendVoiceActivityDetectionSetting() {}
 
+    // Start/stop LC3 audio playback from glasses based on the nex_audio_playback flag.
+    open fun applyNexAudioPlaybackSetting() {}
+
     // Version info
     abstract fun requestVersionInfo()
 
@@ -161,7 +211,9 @@ abstract class SGCManager {
         get() = DeviceStore.get("glasses", "micEnabled") as? Boolean ?: false
 
     val voiceActivityDetectionEnabled: Boolean
-        get() = DeviceStore.get("glasses", "voiceActivityDetectionEnabled") as? Boolean ?: true
+        get() =
+            DeviceStore.get("glasses", "voiceActivityDetectionEnabled") as? Boolean
+                ?: BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED
 
     val batteryLevel: Int
         get() = DeviceStore.get("glasses", "batteryLevel") as? Int ?: -1

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/Simulated.kt

@@ -1,10 +1,11 @@
 package com.mentra.bluetoothsdk.sgcs
 
+import com.mentra.bluetoothsdk.BluetoothSdkDefaults
 import com.mentra.bluetoothsdk.Bridge
 import com.mentra.bluetoothsdk.DeviceManager
+import com.mentra.bluetoothsdk.DeviceStore
 import com.mentra.bluetoothsdk.utils.ConnTypes
 import com.mentra.bluetoothsdk.utils.DeviceTypes
-import com.mentra.bluetoothsdk.DeviceStore
 
 class Simulated : SGCManager() {
 
@@ -14,7 +15,11 @@ class Simulated : SGCManager() {
         DeviceStore.apply("glasses", "connected", true)
         DeviceStore.apply("glasses", "connectionState", ConnTypes.CONNECTED)
         DeviceStore.apply("glasses", "micEnabled", false)
-        DeviceStore.apply("glasses", "voiceActivityDetectionEnabled", true)
+        DeviceStore.apply(
+            "glasses",
+            "voiceActivityDetectionEnabled",
+            BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED
+        )
     }
 
     // Audio Control
@@ -35,11 +40,12 @@ class Simulated : SGCManager() {
             authToken: String?,
             compress: String?,
             flash: Boolean,
+            save: Boolean,
             sound: Boolean,
             exposureTimeNs: Long?,
             iso: Int?,
     ) {
-        Bridge.log("requestPhoto flash=$flash, sound=$sound")
+        Bridge.log("requestPhoto flash=$flash, save=$save, sound=$sound")
     }
 
     override fun startStream(message: MutableMap<String, Any>) {
@@ -100,7 +106,13 @@ class Simulated : SGCManager() {
         Bridge.log("sendDoubleTextWall")
     }
 
-    override fun displayBitmap(base64ImageData: String): Boolean {
+    override fun displayBitmap(
+            base64ImageData: String,
+            x: Int?,
+            y: Int?,
+            width: Int?,
+            height: Int?
+    ): Boolean {
         Bridge.log("displayBitmap")
         return false
     }

package/android/src/main/java/com/mentra/bluetoothsdk/status/DeviceStatus.kt

@@ -47,6 +47,7 @@ internal data class GlassesStatus(
     val rightMacAddress: String,
     val macAddress: String,
     val buildNumber: String,
+    val systemTimeMs: Long?,
     val otaVersionUrl: String,
     val appVersion: String,
     val bluetoothName: String,
@@ -69,8 +70,9 @@ internal data class GlassesStatus(
     val controllerSignalStrength: Int,
     val ringSignalStrength: Int,
 ) {
-    internal fun toMap(): Map<String, Any> =
-        mapOf(
+    internal fun toMap(): Map<String, Any> {
+        val values =
+            mutableMapOf<String, Any>(
             "connection" to connectionState.toStatusMap(connected, fullyBooted),
             "micEnabled" to micEnabled,
             "voiceActivityDetectionEnabled" to voiceActivityDetectionEnabled,
@@ -109,6 +111,9 @@ internal data class GlassesStatus(
             "controllerSignalStrength" to controllerSignalStrength,
             "ringSignalStrength" to ringSignalStrength,
         )
+        systemTimeMs?.let { values["systemTimeMs"] = it }
+        return values
+    }
 
     companion object {
         internal fun fromMap(values: Map<String, Any>): GlassesStatus =
@@ -116,7 +121,9 @@ internal data class GlassesStatus(
                 fullyBooted = boolValue(values, "fullyBooted") ?: false,
                 connected = boolValue(values, "connected") ?: false,
                 micEnabled = boolValue(values, "micEnabled") ?: false,
-                voiceActivityDetectionEnabled = boolValue(values, "voiceActivityDetectionEnabled") ?: true,
+                voiceActivityDetectionEnabled =
+                    boolValue(values, "voiceActivityDetectionEnabled")
+                        ?: BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED,
                 connectionState = GlassesConnectionState.fromValue(stringValue(values, "connectionState")),
                 bluetoothClassicConnected = boolValue(values, "bluetoothClassicConnected") ?: false,
                 signalStrength = numberValue(values, "signalStrength") ?: -1,
@@ -131,6 +138,7 @@ internal data class GlassesStatus(
                 rightMacAddress = stringValue(values, "rightMacAddress") ?: "",
                 macAddress = stringValue(values, "macAddress") ?: "",
                 buildNumber = stringValue(values, "buildNumber") ?: "",
+                systemTimeMs = longValue(values, "systemTimeMs"),
                 otaVersionUrl = stringValue(values, "otaVersionUrl") ?: "",
                 appVersion = stringValue(values, "appVersion") ?: "",
                 bluetoothName = stringValue(values, "bluetoothName") ?: "",
@@ -156,6 +164,55 @@ internal data class GlassesStatus(
     }
 }
 
+data class VersionInfoResult(
+    val androidVersion: String,
+    val firmwareVersion: String,
+    val besFirmwareVersion: String,
+    val mtkFirmwareVersion: String,
+    val buildNumber: String,
+    val systemTimeMs: Long?,
+    val otaVersionUrl: String,
+    val appVersion: String,
+) {
+    internal fun toMap(): Map<String, Any> =
+        buildMap {
+            put("androidVersion", androidVersion)
+            put("firmwareVersion", firmwareVersion)
+            put("besFirmwareVersion", besFirmwareVersion)
+            put("mtkFirmwareVersion", mtkFirmwareVersion)
+            put("buildNumber", buildNumber)
+            systemTimeMs?.let { put("systemTimeMs", it) }
+            put("otaVersionUrl", otaVersionUrl)
+            put("appVersion", appVersion)
+        }
+
+    companion object {
+        internal fun from(status: GlassesStatus): VersionInfoResult =
+            VersionInfoResult(
+                androidVersion = status.androidVersion,
+                firmwareVersion = status.firmwareVersion,
+                besFirmwareVersion = status.besFirmwareVersion,
+                mtkFirmwareVersion = status.mtkFirmwareVersion,
+                buildNumber = status.buildNumber,
+                systemTimeMs = status.systemTimeMs,
+                otaVersionUrl = status.otaVersionUrl,
+                appVersion = status.appVersion,
+            )
+
+        internal fun fromMap(values: Map<String, Any>): VersionInfoResult =
+            VersionInfoResult(
+                androidVersion = stringValue(values, "androidVersion", "android_version") ?: "",
+                firmwareVersion = stringValue(values, "firmwareVersion", "firmware_version") ?: "",
+                besFirmwareVersion = stringValue(values, "besFirmwareVersion", "bes_fw_version") ?: "",
+                mtkFirmwareVersion = stringValue(values, "mtkFirmwareVersion", "mtk_fw_version") ?: "",
+                buildNumber = stringValue(values, "buildNumber", "build_number") ?: "",
+                systemTimeMs = longValue(values, "systemTimeMs", "system_time_ms"),
+                otaVersionUrl = stringValue(values, "otaVersionUrl", "ota_version_url") ?: "",
+                appVersion = stringValue(values, "appVersion", "app_version") ?: "",
+            )
+    }
+}
+
 internal data class BluetoothStatus(
     val searching: Boolean,
     val searchingController: Boolean,

package/android/src/main/java/com/mentra/bluetoothsdk/streaming/StreamModels.kt

@@ -56,13 +56,20 @@ data class StreamAudioConfig @JvmOverloads constructor(
     }
 }
 
+/** Effective video settings reported by the glasses after defaults and clamps. */
 data class StreamResolvedVideoConfig @JvmOverloads constructor(
+    /** Encoded output width sent to the stream endpoint. */
     val width: Int,
+    /** Encoded output height sent to the stream endpoint. */
     val height: Int,
+    /** Native camera buffer width selected before crop/downscale. */
     val captureWidth: Int? = null,
+    /** Native camera buffer height selected before crop/downscale. */
     val captureHeight: Int? = null,
+    /** Encoded video bitrate in bits per second. */
     val bitrate: Int,
-    val fps: Int,
+    /** Resolved capture/encode frame rate. */
+    val fps: Double,
 ) {
     fun toMap(): Map<String, Any> =
         buildMap {
@@ -84,7 +91,7 @@ data class StreamResolvedVideoConfig @JvmOverloads constructor(
                 captureWidth = numberValue(values, "captureWidth"),
                 captureHeight = numberValue(values, "captureHeight"),
                 bitrate = numberValue(values, "bitrate") ?: return null,
-                fps = numberValue(values, "fps") ?: return null,
+                fps = doubleValue(values, "fps") ?: return null,
             )
         }
     }
@@ -377,12 +384,14 @@ sealed interface StreamStatus {
             val resolvedConfig = StreamResolvedConfig.fromMap(stringMapValue(values["resolvedConfig"]))
             val attempt = numberValue(values, "attempt")
             val maxAttempts = numberValue(values, "maxAttempts") ?: 0
+            val parsedState = StreamState.fromValue(rawState)
 
             if (streaming != null || hasAnyKey(values, "reconnecting")) {
                 return Snapshot(
                     state = when {
                         reconnecting -> StreamState.RECONNECTING
                         streaming == true -> StreamState.STREAMING
+                        parsedState != null -> parsedState
                         else -> StreamState.STOPPED
                     },
                     streaming = streaming == true,
@@ -394,7 +403,7 @@ sealed interface StreamStatus {
                 )
             }
 
-            val state = StreamState.fromValue(rawState)
+            val state = parsedState
                 ?: return Error(
                     streamId = streamId,
                     errorDetails = rawState?.let { "Unknown stream status: $it" } ?: "Missing stream status",

package/android/src/main/java/com/mentra/bluetoothsdk/stt/STTTools.kt

@@ -8,9 +8,56 @@ import java.io.BufferedOutputStream
 import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
+import java.io.InputStream
 import org.apache.commons.compress.archivers.tar.TarArchiveInputStream
 import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream
 
+/**
+ * Wraps an InputStream so we can observe how many compressed bytes have been
+ * consumed from the source .tar.bz2. Used to report extraction progress to JS
+ * — bz2 reads sequentially, so bytes-consumed/total is a reasonable proxy for
+ * "% of work done".
+ */
+private class ProgressInputStream(
+        private val wrapped: InputStream,
+        private val totalBytes: Long,
+        private val onProgress: (Long, Long) -> Unit,
+) : InputStream() {
+    private var bytesRead: Long = 0
+    private var lastEmittedAt: Long = 0
+    private val emitIntervalMs = 200L
+
+    override fun read(): Int {
+        val byte = wrapped.read()
+        if (byte != -1) {
+            bytesRead++
+            maybeEmit()
+        }
+        return byte
+    }
+
+    override fun read(b: ByteArray, off: Int, len: Int): Int {
+        val n = wrapped.read(b, off, len)
+        if (n > 0) {
+            bytesRead += n
+            maybeEmit()
+        }
+        return n
+    }
+
+    override fun close() {
+        wrapped.close()
+    }
+
+    private fun maybeEmit() {
+        val now = System.currentTimeMillis()
+        if (now - lastEmittedAt >= emitIntervalMs) {
+            lastEmittedAt = now
+            onProgress(bytesRead, totalBytes)
+        }
+    }
+}
+
 /**
  * STTTools provides utilities for STT model management.
  *
@@ -85,21 +132,26 @@ object STTTools {
             }
 
             // Check for CTC model
-            val ctcModelFile = File(modelDir, "model.int8.onnx")
+            val ctcModelFile = findReadableFile(modelDir, listOf("model.int8.onnx", "model.onnx"))
             if (ctcModelFile.exists() && ctcModelFile.canRead() && ctcModelFile.length() > 0) {
                 Bridge.log("STT CTC model found at: $path (size: ${ctcModelFile.length()} bytes)")
                 return true
             }
 
             // Check for transducer model
-            val transducerFiles = listOf("encoder.onnx", "decoder.onnx", "joiner.onnx")
+            val transducerFiles =
+                    listOf(
+                            "encoder" to listOf("encoder.onnx", "encoder.int8.onnx"),
+                            "decoder" to listOf("decoder.onnx", "decoder.int8.onnx"),
+                            "joiner" to listOf("joiner.onnx", "joiner.int8.onnx")
+                    )
             val allTransducerFilesPresent =
-                    transducerFiles.all { fileName ->
-                        val file = File(modelDir, fileName)
+                    transducerFiles.all { (label, candidates) ->
+                        val file = findReadableFile(modelDir, candidates)
                         val exists = file.exists() && file.canRead() && file.length() > 0
                         if (!exists) {
                             Bridge.log(
-                                    "STT model missing or invalid transducer file: $fileName at $path"
+                                    "STT model missing or invalid transducer file: $label at $path"
                             )
                         }
                         exists
@@ -153,9 +205,17 @@ object STTTools {
             var fileCount = 0
             var bytesExtracted = 0L
 
+            val totalCompressedBytes = sourceFile.length()
+            Bridge.sendExtractionProgress(0, 0, totalCompressedBytes)
+
             // Open the tar.bz2 file with buffered streams for better performance
             FileInputStream(sourceFile).use { fis ->
-                BufferedInputStream(fis).use { bis ->
+                ProgressInputStream(fis, totalCompressedBytes) { read, total ->
+                    val pct =
+                            if (total > 0) ((read * 99L) / total).coerceIn(0L, 99L).toInt() else 0
+                    Bridge.sendExtractionProgress(pct, read, total)
+                }.use { progress ->
+                BufferedInputStream(progress, 65536).use { bis ->
                     Bridge.log("Opening bz2 decompression stream...")
                     BZip2CompressorInputStream(bis).use { bzIn ->
                         Bridge.log("Opening tar archive stream...")
@@ -166,31 +226,25 @@ object STTTools {
                             while (entry != null) {
                                 try {
                                     val outputFile = File(destDir, entry.name)
-                                    Bridge.log(
-                                            "Processing entry: ${entry.name} (${entry.size} bytes, isDir=${entry.isDirectory})"
-                                    )
 
                                     if (entry.isDirectory) {
-                                        // Create directory
                                         if (!outputFile.exists()) {
                                             outputFile.mkdirs()
                                         }
                                     } else {
-                                        // Create parent directories if needed
                                         outputFile.parentFile?.let { parent ->
                                             if (!parent.exists()) {
                                                 parent.mkdirs()
                                             }
                                         }
 
-                                        // Extract file with buffered output for better performance
                                         FileOutputStream(outputFile).use { fos ->
-                                            BufferedOutputStream(fos).use { bos ->
-                                                val buffer =
-                                                        ByteArray(
-                                                                4096
-                                                        ) // Use 4KB buffer like original
-                                                // implementation
+                                            BufferedOutputStream(fos, 65536).use { bos ->
+                                                // 64KB buffer matches iOS path and cuts JNI/stream
+                                                // overhead ~16x vs. the prior 4KB. The per-read
+                                                // progress hook is already 200ms-throttled by
+                                                // ProgressInputStream, so we don't log per-chunk.
+                                                val buffer = ByteArray(65536)
                                                 var len: Int
                                                 var fileBytes = 0L
                                                 val fileSizeMB = entry.size / 1024 / 1024
@@ -201,16 +255,13 @@ object STTTools {
                                                     fileBytes += len
                                                     bytesExtracted += len
 
-                                                    // For large files (>10MB), log progress every
-                                                    // 10MB
                                                     if (fileSizeMB > 10) {
                                                         val currentMB = fileBytes / 1024 / 1024
                                                         if (currentMB >= lastProgressMB + 10) {
                                                             lastProgressMB = currentMB
                                                             val percent =
                                                                     if (entry.size > 0)
-                                                                            (fileBytes * 100 /
-                                                                                    entry.size)
+                                                                            (fileBytes * 100 / entry.size)
                                                                     else 0
                                                             Bridge.log(
                                                                     "  Extracting ${entry.name}: ${currentMB}MB / ${fileSizeMB}MB (${percent}%)"
@@ -220,21 +271,11 @@ object STTTools {
                                                 }
 
                                                 fileCount++
-
-                                                // Log progress every file for debugging
-                                                val mbExtracted = bytesExtracted / 1024 / 1024
-                                                Bridge.log(
-                                                        "Extracted file $fileCount (${mbExtracted}MB total) - ${entry.name}"
-                                                )
                                             }
                                         }
                                     }
 
-                                    Bridge.log("Getting next entry...")
                                     entry = tarIn.nextEntry
-                                    Bridge.log(
-                                            "Next entry received: ${entry?.name ?: "null (end of archive)"}"
-                                    )
                                 } catch (e: Exception) {
                                     Bridge.log(
                                             "ERROR extracting entry ${entry?.name}: ${e.javaClass.simpleName}: ${e.message}"
@@ -248,8 +289,11 @@ object STTTools {
                         }
                     }
                 }
+                }
             }
 
+            Bridge.sendExtractionProgress(100, totalCompressedBytes, totalCompressedBytes)
+
             val duration = (System.currentTimeMillis() - startTime) / 1000
             val mbExtracted = bytesExtracted / 1024 / 1024
             Bridge.log(
@@ -290,11 +334,12 @@ object STTTools {
             if (actualModelDir != destDir) {
                 Bridge.log("Moving files from subdirectory to parent directory")
                 actualModelDir.listFiles()?.forEach { file ->
-                    if (!file.isDirectory) {
-                        val targetFile = File(destDir, file.name)
-                        Bridge.log("Moving ${file.name}")
-                        file.renameTo(targetFile)
+                    val targetFile = File(destDir, file.name)
+                    if (targetFile.exists()) {
+                        targetFile.deleteRecursively()
                     }
+                    Bridge.log("Moving ${file.name}")
+                    file.renameTo(targetFile)
                 }
                 // Delete the now-empty subdirectory
                 actualModelDir.delete()
@@ -313,6 +358,12 @@ object STTTools {
         return context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
     }
 
+    private fun findReadableFile(modelDir: File, candidates: List<String>): File {
+        return candidates.map { File(modelDir, it) }.firstOrNull { file ->
+            file.exists() && file.canRead() && file.length() > 0
+        } ?: File(modelDir, candidates.first())
+    }
+
     /** Clear all STT model settings */
     fun clearSttModelSettings(context: Context) {
         val prefs = getPrefs(context)

package/android/src/main/java/com/mentra/bluetoothsdk/stt/SherpaOnnxTranscriber.kt

@@ -122,8 +122,9 @@ class SherpaOnnxTranscriber(private val context: Context) {
             val modelConfig = OnlineModelConfig()
 
             // Detect model type based on available files
-            val ctcModelFile = File(modelDir, "model.int8.onnx")
-            val transducerEncoderFile = File(modelDir, "encoder.onnx")
+            val ctcModelFile = findReadableFile(modelDir, listOf("model.int8.onnx", "model.onnx"))
+            val transducerEncoderFile =
+                    findReadableFile(modelDir, listOf("encoder.onnx", "encoder.int8.onnx"))
 
             when {
                 ctcModelFile.exists() -> {
@@ -143,8 +144,10 @@ class SherpaOnnxTranscriber(private val context: Context) {
                     modelType = "transducer"
                     Bridge.log("Detected transducer model at $modelPath")
 
-                    val decoderFile = File(modelDir, "decoder.onnx")
-                    val joinerFile = File(modelDir, "joiner.onnx")
+                    val decoderFile =
+                            findReadableFile(modelDir, listOf("decoder.onnx", "decoder.int8.onnx"))
+                    val joinerFile =
+                            findReadableFile(modelDir, listOf("joiner.onnx", "joiner.int8.onnx"))
 
                     if (!decoderFile.exists() || !joinerFile.exists()) {
                         throw IllegalStateException(
@@ -222,6 +225,12 @@ class SherpaOnnxTranscriber(private val context: Context) {
         }
     }
 
+    private fun findReadableFile(modelDir: File, candidates: List<String>): File {
+        return candidates.map { File(modelDir, it) }.firstOrNull { file ->
+            file.exists() && file.canRead() && file.length() > 0
+        } ?: File(modelDir, candidates.first())
+    }
+
     /**
      * Feed PCM audio data (16-bit little endian) into the transcriber. This method should be called
      * continuously with short chunks (e.g., 100-300ms).