@mentra/bluetooth-sdk 0.1.12 → 0.1.13

package/android/src/main/java/com/mentra/bluetoothsdk/OtaManifest.kt

@@ -0,0 +1,153 @@
+package com.mentra.bluetoothsdk
+
+import java.net.HttpURLConnection
+import java.net.URI
+import java.net.URL
+import org.json.JSONArray
+import org.json.JSONObject
+
+internal object OtaManifestDefaults {
+    private const val SDK_OTA_RELEASE_BASE_URL =
+        "https://github.com/Mentra-Community/MentraOS/releases/download/bluetooth-sdk-ota"
+    // Keep prod as the legacy-device fallback: pre-override ASG builds ignore
+    // ota_start.ota_version_url and use their compiled MentraOS default.
+    const val PROD_OTA_VERSION_URL = "https://ota.mentraglass.com/prod_live_version.json"
+
+    fun defaultOtaVersionUrl(): String {
+        val sdkVersion = BuildConfig.SDK_VERSION.trim()
+        if (sdkVersion.isBlank() || sdkVersion == "unspecified") {
+            throw BluetoothException(
+                "missing_sdk_version",
+                "Cannot determine Bluetooth SDK version for the default OTA manifest URL.",
+            )
+        }
+        return "$SDK_OTA_RELEASE_BASE_URL/bluetooth-sdk-$sdkVersion-version.json"
+    }
+}
+
+internal object OtaManifestChecker {
+    private const val ASG_CLIENT_PACKAGE = "com.mentra.asg_client"
+
+    fun normalizeHttpUrl(value: String): String {
+        val trimmed = value.trim()
+        if (trimmed.isEmpty()) {
+            throw BluetoothException("invalid_ota_url", "OTA version URL must be a non-empty http(s) URL.")
+        }
+
+        val uri =
+            try {
+                URI(trimmed)
+            } catch (error: Exception) {
+                throw BluetoothException("invalid_ota_url", "OTA version URL must be a valid http(s) URL.", error)
+            }
+
+        val scheme = uri.scheme?.lowercase()
+        if ((scheme != "http" && scheme != "https") || uri.host.isNullOrBlank()) {
+            throw BluetoothException("invalid_ota_url", "OTA version URL must be an http(s) URL.")
+        }
+
+        return uri.toString()
+    }
+
+    fun fetch(otaVersionUrl: String): JSONObject {
+        val connection = URL(otaVersionUrl).openConnection() as HttpURLConnection
+        connection.connectTimeout = 15_000
+        connection.readTimeout = 15_000
+        connection.requestMethod = "GET"
+        return try {
+            val status = connection.responseCode
+            if (status !in 200..299) {
+                throw BluetoothException("ota_manifest_request_failed", "OTA manifest request failed with HTTP $status.")
+            }
+            JSONObject(connection.inputStream.bufferedReader().use { it.readText() })
+        } finally {
+            connection.disconnect()
+        }
+    }
+
+    fun hasUpdate(
+        currentBuildNumber: String,
+        currentMtkVersion: String,
+        currentBesVersion: String,
+        manifest: JSONObject,
+    ): Boolean =
+        hasApkUpdate(currentBuildNumber, manifest) ||
+            hasMtkUpdate(manifest.optJSONArray("mtk_patches"), currentMtkVersion) ||
+            hasBesUpdate(manifest.optJSONObject("bes_firmware"), currentBesVersion)
+
+    fun hasMtkPatches(manifest: JSONObject): Boolean =
+        (manifest.optJSONArray("mtk_patches")?.length() ?: 0) > 0
+
+    fun hasBesFirmware(manifest: JSONObject): Boolean =
+        manifest.optJSONObject("bes_firmware") != null
+
+    private fun latestAppInfo(manifest: JSONObject): JSONObject {
+        val apps = manifest.optJSONObject("apps")
+        val app = apps?.optJSONObject(ASG_CLIENT_PACKAGE)
+        if (app != null && app.hasNumber("versionCode")) {
+            return app
+        }
+
+        if (manifest.hasNumber("versionCode")) {
+            return manifest
+        }
+
+        throw BluetoothException("invalid_ota_manifest", "OTA manifest is missing ASG app versionCode.")
+    }
+
+    private fun hasApkUpdate(currentBuildNumber: String, manifest: JSONObject): Boolean {
+        val currentVersion =
+            currentBuildNumber.toLongOrNull()
+                ?: throw BluetoothException(
+                    "invalid_glasses_version",
+                    "Cannot check OTA update because glasses build number is invalid.",
+                )
+        val serverVersion = latestAppInfo(manifest).requiredLong("versionCode")
+        return serverVersion > currentVersion
+    }
+
+    private fun hasMtkUpdate(patches: JSONArray?, currentVersion: String): Boolean {
+        if (patches == null || patches.length() == 0) return false
+        if (currentVersion.isBlank()) return false
+
+        for (index in 0 until patches.length()) {
+            val patch = patches.optJSONObject(index) ?: continue
+            val startFirmware = patch.optString("start_firmware", "")
+            if (startFirmware == currentVersion) return true
+            val serverDate = if (startFirmware.contains("_")) startFirmware.substringAfterLast("_") else startFirmware
+            if (serverDate == currentVersion) return true
+        }
+        return false
+    }
+
+    private fun hasBesUpdate(besFirmware: JSONObject?, currentVersion: String): Boolean {
+        if (besFirmware == null) return false
+        val serverVersion = besFirmware.optString("version", "")
+        if (serverVersion.isBlank()) {
+            throw BluetoothException("invalid_ota_manifest", "OTA manifest bes_firmware.version is missing.")
+        }
+        if (currentVersion.isBlank()) return true
+        return compareVersions(serverVersion, currentVersion) > 0
+    }
+
+    private fun compareVersions(version1: String, version2: String): Int {
+        if (version1.contains(".") && version2.contains(".")) {
+            val parts1 = version1.split(".")
+            val parts2 = version2.split(".")
+            val maxLength = maxOf(parts1.size, parts2.size)
+            for (index in 0 until maxLength) {
+                val value1 = parts1.getOrNull(index)?.toIntOrNull() ?: 0
+                val value2 = parts2.getOrNull(index)?.toIntOrNull() ?: 0
+                if (value1 != value2) return value1 - value2
+            }
+            return 0
+        }
+        return version1.compareTo(version2)
+    }
+
+    private fun JSONObject.hasNumber(key: String): Boolean = !isNull(key) && opt(key) is Number
+
+    private fun JSONObject.requiredLong(key: String): Long =
+        (opt(key) as? Number)?.toLong()
+            ?: throw BluetoothException("invalid_ota_manifest", "OTA manifest is missing ASG app versionCode.")
+}

package/android/src/main/java/com/mentra/bluetoothsdk/camera/CameraModels.kt

@@ -1,28 +1,46 @@
 package com.mentra.bluetoothsdk
 
+import org.json.JSONObject
+
 enum class PhotoSize(val value: String) {
-    SMALL("small"),
+    LOW("low"),
     MEDIUM("medium"),
-    LARGE("large"),
-    FULL("full");
+    HIGH("high"),
+    MAX("max");
 
     companion object {
         @JvmStatic
-        fun fromValue(value: String?): PhotoSize =
-            values().firstOrNull { it.value == value } ?: MEDIUM
+        fun normalizeLegacy(value: String?): String =
+            when (value) {
+                "small" -> LOW.value
+                "large" -> HIGH.value
+                "full" -> MAX.value
+                else -> value ?: MEDIUM.value
+            }
+
+        @JvmStatic
+        fun fromValue(value: String?): PhotoSize {
+            val normalized = normalizeLegacy(value)
+            return values().firstOrNull { it.value == normalized } ?: MEDIUM
+        }
     }
 }
 
 enum class ButtonPhotoSize(val value: String) {
-    SMALL("small"),
+    LOW("low"),
     MEDIUM("medium"),
-    LARGE("large"),
+    HIGH("high"),
     MAX("max");
 
     companion object {
         @JvmStatic
-        fun fromValue(value: String?): ButtonPhotoSize =
-            values().firstOrNull { it.value == value } ?: MEDIUM
+        fun normalizeLegacy(value: String?): String = PhotoSize.normalizeLegacy(value)
+
+        @JvmStatic
+        fun fromValue(value: String?): ButtonPhotoSize {
+            val normalized = normalizeLegacy(value)
+            return values().firstOrNull { it.value == normalized } ?: MEDIUM
+        }
     }
 }
 
@@ -39,7 +57,18 @@ enum class PhotoCompression(val value: String) {
 }
 
 data class ButtonPhotoSettings(
-    val size: ButtonPhotoSize,
+    val size: ButtonPhotoSize? = null,
+    val mfnr: Boolean? = null,
+    val zsl: Boolean? = null,
+    val noiseReduction: Boolean? = null,
+    val edgeEnhancement: Boolean? = null,
+    val ispDigitalGain: Int? = null,
+    val ispAnalogGain: String? = null,
+    val aeExposureDivisor: Int? = null,
+    val isoCap: Int? = null,
+    val compress: String? = null,
+    val sound: Boolean? = null,
+    val resetCaptureTuning: Boolean = false,
 )
 
 data class ButtonVideoRecordingSettings(
@@ -145,6 +174,15 @@ data class PhotoRequest @JvmOverloads constructor(
     val exposureTimeNs: Double? = null,
     /** Sensor ISO for this capture only. Only used when exposureTimeNs enables manual exposure. */
     val iso: Int? = null,
+    val aeExposureDivisor: Int? = null,
+    val isoCap: Int? = null,
+    val noiseReduction: Boolean? = null,
+    val edgeEnhancement: Boolean? = null,
+    val mfnr: Boolean? = null,
+    val zsl: Boolean? = null,
+    val ispDigitalGain: Int? = null,
+    val ispAnalogGain: String? = null,
+    val resetCaptureTuning: Boolean? = null,
 ) {
     companion object {
         /** Mirrors iOS `BluetoothSdkModule` defaults for keys omitted from the JS bridge. */
@@ -167,6 +205,12 @@ data class PhotoRequest @JvmOverloads constructor(
                     }
                     else -> null
                 }
+            val aeDivisor =
+                numberValue(values, "aeExposureDivisor")?.takeIf { it > 1 }
+            val isoCap = numberValue(values, "isoCap")?.takeIf { it > 0 }
+            val ispDigitalGain = numberValue(values, "ispDigitalGain")
+            val ispAnalogGain = stringValue(values, "ispAnalogGain")
+
             return PhotoRequest(
                 requestId = stringValue(values, "requestId", "request_id").orEmpty(),
                 appId = stringValue(values, "appId", "app_id").orEmpty(),
@@ -179,8 +223,32 @@ data class PhotoRequest @JvmOverloads constructor(
                 sound = boolValue(values, "sound") ?: true,
                 exposureTimeNs = exposureTimeNs,
                 iso = iso,
+                aeExposureDivisor = aeDivisor,
+                isoCap = isoCap,
+                noiseReduction = boolValue(values, "noiseReduction"),
+                edgeEnhancement = boolValue(values, "edgeEnhancement"),
+                mfnr = boolValue(values, "mfnr"),
+                zsl = boolValue(values, "zsl"),
+                ispDigitalGain = ispDigitalGain,
+                ispAnalogGain = ispAnalogGain,
             )
         }
+
+        /** Adds optional scan-mode tuning fields to a `take_photo` JSON payload. */
+        @JvmStatic
+        fun appendScanFields(
+            json: JSONObject,
+            request: PhotoRequest,
+        ) {
+            request.aeExposureDivisor?.let { json.put("aeExposureDivisor", it) }
+            request.isoCap?.let { json.put("isoCap", it) }
+            request.noiseReduction?.let { json.put("noiseReduction", it) }
+            request.edgeEnhancement?.let { json.put("edgeEnhancement", it) }
+            request.mfnr?.let { json.put("mfnr", it) }
+            request.zsl?.let { json.put("zsl", it) }
+            request.ispDigitalGain?.let { json.put("ispDigitalGain", it) }
+            request.ispAnalogGain?.let { json.put("ispAnalogGain", it) }
+        }
     }
 }
 

package/android/src/main/java/com/mentra/bluetoothsdk/controllers/ControllerManager.kt

@@ -2,6 +2,7 @@ package com.mentra.bluetoothsdk.controllers
 
 import com.mentra.bluetoothsdk.BluetoothSdkDefaults
 import com.mentra.bluetoothsdk.DeviceStore
+import com.mentra.bluetoothsdk.PhotoRequest
 
 abstract class ControllerManager {
     @JvmField var type: String = ""
@@ -15,19 +16,7 @@ abstract class ControllerManager {
     abstract fun sendJson(jsonOriginal: Map<String, Any>, wakeUp: Boolean, requireAck: Boolean)
 
     // Camera & Media
-    abstract fun requestPhoto(
-        requestId: String,
-        appId: String,
-        size: String?,
-        webhookUrl: String?,
-        authToken: String?,
-        compress: String?,
-        flash: Boolean,
-        save: Boolean,
-        sound: Boolean,
-        exposureTimeNs: Long?,
-        iso: Int?,
-    )
+    abstract fun requestPhoto(request: PhotoRequest)
     abstract fun startStream(message: Map<String, Any>)
     abstract fun stopStream()
     abstract fun sendStreamKeepAlive(message: Map<String, Any>)
@@ -87,7 +76,7 @@ abstract class ControllerManager {
     abstract fun sendWifiCredentials(ssid: String, password: String)
     abstract fun forgetWifiNetwork(ssid: String)
     abstract fun sendHotspotState(enabled: Boolean)
-    abstract fun sendOtaStart()
+    abstract fun sendOtaStart(otaVersionUrl: String? = null)
 
     // User Context (for crash reporting)
     abstract fun sendUserEmailToGlasses(email: String)

package/android/src/main/java/com/mentra/bluetoothsdk/controllers/R1.kt

@@ -1,5 +1,6 @@
 package com.mentra.bluetoothsdk.controllers
 
+import com.mentra.bluetoothsdk.PhotoRequest
 import android.Manifest
 import android.bluetooth.BluetoothAdapter
 import android.bluetooth.BluetoothDevice
@@ -861,11 +862,7 @@ class R1 : ControllerManager() {
     override fun setMicEnabled(enabled: Boolean) {}
     override fun sortMicRanking(list: MutableList<String>): MutableList<String> = list
     override fun sendJson(jsonOriginal: Map<String, Any>, wakeUp: Boolean, requireAck: Boolean) {}
-    override fun requestPhoto(
-        requestId: String, appId: String, size: String?, webhookUrl: String?,
-        authToken: String?, compress: String?, flash: Boolean, save: Boolean, sound: Boolean,
-        exposureTimeNs: Long?, iso: Int?,
-    ) {}
+    override fun requestPhoto(request: PhotoRequest) {}
     override fun startVideoRecording(requestId: String, save: Boolean, flash: Boolean, sound: Boolean) {}
     override fun stopVideoRecording(requestId: String) {}
     override fun startStream(message: Map<String, Any>) {}
@@ -901,7 +898,7 @@ class R1 : ControllerManager() {
     override fun sendWifiCredentials(ssid: String, password: String) {}
     override fun forgetWifiNetwork(ssid: String) {}
     override fun sendHotspotState(enabled: Boolean) {}
-    override fun sendOtaStart() {}
+    override fun sendOtaStart(otaVersionUrl: String?) {}
     override fun sendUserEmailToGlasses(email: String) {}
     override fun queryGalleryStatus() {}
     override fun sendGalleryMode() {}

package/android/src/main/java/com/mentra/bluetoothsdk/services/PhoneMic.kt

@@ -49,6 +49,7 @@ class PhoneMic private constructor(private val context: Context) {
         private const val FOCUS_REGAIN_DELAY_MS = 500L
         private const val SAMSUNG_MIC_TEST_DELAY_MS = 500L
         private const val MIC_SWITCH_DELAY_MS = 300L // Time for DeviceManager to switch mics
+        private const val AUDIO_SOURCE_HOTWORD = 1999
     }
 
     // Audio recording components
@@ -185,7 +186,42 @@ class PhoneMic private constructor(private val context: Context) {
     }
 
     fun isRecordingWithMode(mode: String): Boolean {
-        return isRecording.get() && currentMicMode == mode
+        if (!isRecording.get()) {
+            return false
+        }
+
+        val record = audioRecord
+        val activelyRecording =
+                try {
+                    record?.recordingState == AudioRecord.RECORDSTATE_RECORDING
+                } catch (e: Exception) {
+                    Bridge.log("MIC: Failed to read AudioRecord state: ${e.message}")
+                    false
+                }
+
+        if (!activelyRecording) {
+            Bridge.log("MIC: Stale recording state detected, cleaning up")
+            cleanUpRecording()
+            abandonAudioFocus()
+            currentMicMode = ""
+            return false
+        }
+
+        return currentMicMode == mode
+    }
+
+    fun hasBlockingMicInterruption(): Boolean {
+        val callActive =
+                isPhoneCallActive ||
+                        try {
+                            (telephonyManager?.callState ?: TelephonyManager.CALL_STATE_IDLE) !=
+                                    TelephonyManager.CALL_STATE_IDLE
+                        } catch (e: Exception) {
+                            Bridge.log("MIC: Failed to read telephony call state: ${e.message}")
+                            true
+                        }
+
+        return callActive || isExternalAudioActive
     }
 
     /**
@@ -544,7 +580,23 @@ class PhoneMic private constructor(private val context: Context) {
         audioRecord?.let { ourAudioSessionIds.add(it.audioSessionId) }
 
         // Start recording
-        audioRecord?.startRecording()
+        val record = audioRecord ?: return false
+        try {
+            record.startRecording()
+        } catch (e: Exception) {
+            Bridge.log("MIC: AudioRecord.startRecording() failed: ${e.message}")
+            audioRecord?.release()
+            audioRecord = null
+            return false
+        }
+
+        if (record.recordingState != AudioRecord.RECORDSTATE_RECORDING) {
+            Bridge.log("MIC: AudioRecord did not enter recording state")
+            record.release()
+            audioRecord = null
+            return false
+        }
+
         isRecording.set(true)
 
         // Start recording thread
@@ -577,15 +629,22 @@ class PhoneMic private constructor(private val context: Context) {
 
                     val audioBuffer = ShortArray(bufferSize / 2)
 
+                    var unexpectedStopReason: String? = null
+
                     while (isRecording.get()) {
                         // Capture local reference to avoid use-after-free if cleanUpRecording()
                         // releases the AudioRecord while we're in read()
-                        val record = audioRecord ?: break
+                        val record = audioRecord
+                        if (record == null) {
+                            unexpectedStopReason = "AudioRecord missing"
+                            break
+                        }
 
                         val readResult = try {
                             record.read(audioBuffer, 0, audioBuffer.size)
                         } catch (e: Exception) {
                             Bridge.log("MIC: AudioRecord.read() exception: ${e.message}")
+                            unexpectedStopReason = "AudioRecord.read() exception: ${e.message}"
                             break
                         }
 
@@ -603,9 +662,16 @@ class PhoneMic private constructor(private val context: Context) {
                         } else if (readResult < 0) {
                             // AudioRecord error (ERROR, ERROR_INVALID_OPERATION, ERROR_BAD_VALUE, ERROR_DEAD_OBJECT)
                             Bridge.log("MIC: AudioRecord.read() returned error: $readResult")
+                            unexpectedStopReason = "AudioRecord.read() error: $readResult"
                             break
                         }
                     }
+
+                    unexpectedStopReason?.let { reason ->
+                        if (isRecording.get()) {
+                            mainHandler.post { handleUnexpectedRecordingStop(reason) }
+                        }
+                    }
                 }
                         .apply {
                             name = "AudioRecordingThread"
@@ -613,6 +679,25 @@ class PhoneMic private constructor(private val context: Context) {
                         }
     }
 
+    private fun handleUnexpectedRecordingStop(reason: String) {
+        if (!isRecording.compareAndSet(true, false)) {
+            return
+        }
+
+        Bridge.log("MIC: Recording stopped unexpectedly: $reason")
+        cleanUpRecording()
+        abandonAudioFocus()
+
+        if (audioManager.isBluetoothScoOn) {
+            audioManager.stopBluetoothSco()
+            audioManager.isBluetoothScoOn = false
+        }
+
+        audioManager.mode = AudioManager.MODE_NORMAL
+        currentMicMode = ""
+        notifyDeviceManager("recording_stopped", getAvailableInputDevices().values.toList())
+    }
+
     private fun cleanUpRecording() {
         isRecording.set(false)
 
@@ -778,7 +863,8 @@ class PhoneMic private constructor(private val context: Context) {
                             // Filter out our own recordings
                             val otherAppRecordings =
                                     configs.filter { config ->
-                                        !ourAudioSessionIds.contains(config.clientAudioSessionId)
+                                        !ourAudioSessionIds.contains(config.clientAudioSessionId) &&
+                                                config.clientAudioSource != AUDIO_SOURCE_HOTWORD
                                     }
 
                             val wasExternalActive = isExternalAudioActive