@mentra/bluetooth-sdk 0.1.13 → 0.1.16

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

@@ -127,7 +127,6 @@ object DeviceStore {
         store.set("bluetooth", "voice_activity_detection_enabled", BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED)
         store.set("bluetooth", "screen_disabled", false)
         store.set("bluetooth", "button_photo_size", "max")
-        store.set("bluetooth", "button_camera_led", true)
         store.set("bluetooth", "button_max_recording_time", 10)
         store.set("bluetooth", "camera_fov", mapOf("fov" to 118, "roi_position" to 0))
         store.set("bluetooth", "button_video_width", 1280)
@@ -143,7 +142,7 @@ object DeviceStore {
         store.set("bluetooth", "use_native_dashboard", false)
         // Mentra Nex feature flags (off by default; toggled from Nex Developer Settings):
         store.set("bluetooth", "nex_chinese_captions", false)
-        store.set("bluetooth", "nex_audio_playback", false)
+        store.set("bluetooth", "nex_lc3_audio_playback", false)
     }
 
     fun get(category: String, key: String): Any? {
@@ -269,9 +268,9 @@ object DeviceStore {
             "bluetooth" to "voice_activity_detection_enabled" -> {
                 DeviceManager.getInstance().sgc?.sendVoiceActivityDetectionSetting()
             }
-            "bluetooth" to "nex_audio_playback" -> {
+            "bluetooth" to "nex_lc3_audio_playback" -> {
                 (value as? Boolean)?.let { enabled ->
-                    Bridge.log("DeviceStore: nex_audio_playback changed to $enabled")
+                    Bridge.log("DeviceStore: nex_lc3_audio_playback changed to $enabled")
                     DeviceManager.getInstance().sgc?.applyNexAudioPlaybackSetting()
                 }
             }
@@ -287,9 +286,6 @@ object DeviceStore {
             "bluetooth" to "button_photo_size" -> {
                 DeviceManager.getInstance().sgc?.sendButtonPhotoSettings()
             }
-            "bluetooth" to "button_camera_led" -> {
-                DeviceManager.getInstance().sgc?.sendButtonCameraLedSetting()
-            }
             "bluetooth" to "button_max_recording_time" -> {
                 DeviceManager.getInstance().sgc?.sendButtonMaxRecordingTime()
             }

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

@@ -31,6 +31,7 @@ class MentraBluetoothSdk private constructor(
     private val streamKeepAliveLock = Any()
     private var activeStreamKeepAlive: ActiveStreamKeepAlive? = null
     private val pendingPhotoRequests = ConcurrentHashMap<String, PendingResponse<PhotoResponseEvent>>()
+    private val pendingCameraStatusRequests = ConcurrentHashMap<String, PendingResponse<CameraStatusEvent>>()
     private val pendingVideoRecordingRequests =
         ConcurrentHashMap<String, PendingVideoRecordingRequest>()
     private val pendingRgbLedRequests = ConcurrentHashMap<String, PendingResponse<RgbLedControlResponseEvent>>()
@@ -116,6 +117,7 @@ class MentraBluetoothSdk private constructor(
 
     private data class PendingWifiScan(
         val pending: PendingResponse<List<WifiScanResult>>,
+        var latestResults: List<WifiScanResult> = emptyList(),
     )
 
     private data class PendingWifiStatusRequest(
@@ -158,13 +160,13 @@ class MentraBluetoothSdk private constructor(
 
         fun await(timeoutMs: Long = DEFAULT_REQUEST_TIMEOUT_MS): T {
             if (!latch.await(timeoutMs, TimeUnit.MILLISECONDS)) {
-                throw BluetoothException(
+                throw BluetoothSdkException(
                     "request_timeout",
                     "$operation timed out waiting for glasses response.",
                 )
             }
             error?.let { throw it }
-            return result ?: throw BluetoothException(
+            return result ?: throw BluetoothSdkException(
                 "empty_response",
                 "$operation completed without a response payload.",
             )
@@ -201,7 +203,7 @@ class MentraBluetoothSdk private constructor(
 
     private fun requireGlassesConnected(operation: String) {
         if (!getRawGlassesStatus().connected) {
-            throw BluetoothException(
+            throw BluetoothSdkException(
                 "glasses_not_connected",
                 "Cannot $operation because glasses are not connected.",
             )
@@ -353,7 +355,7 @@ class MentraBluetoothSdk private constructor(
     fun connectDefault(options: ConnectOptions = ConnectOptions()) {
         val defaultDevice =
             currentDefaultDevice()
-                ?: throw BluetoothException(
+                ?: throw BluetoothSdkException(
                     "default_device_missing",
                     "Set a default glasses device before calling connectDefault.",
                 )
@@ -474,7 +476,7 @@ class MentraBluetoothSdk private constructor(
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "voice_activity_detection_enabled", enabled)
     }
 
-    fun setButtonPhotoSettings(settings: ButtonPhotoSettings): SettingsAckEvent =
+    fun setPhotoCaptureDefaults(settings: PhotoCaptureDefaults): SettingsAckEvent =
         performSettingsCommand(
             setting = "button_photo",
             updateStore = { _ ->
@@ -527,30 +529,20 @@ class MentraBluetoothSdk private constructor(
             send = { requestId -> deviceManager.sendButtonPhotoSettings(requestId, settings) },
         )
 
-    fun setButtonVideoRecordingSettings(width: Int, height: Int, fps: Int): SettingsAckEvent =
+    fun setVideoRecordingDefaults(defaults: VideoRecordingDefaults): SettingsAckEvent =
         performSettingsCommand(
             setting = "button_video_recording",
             updateStore = { _ ->
-                DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_width", width)
-                DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_height", height)
-                DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_fps", fps)
+                DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_width", defaults.width)
+                DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_height", defaults.height)
+                DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_fps", defaults.fps)
             },
             send = { requestId ->
-                deviceManager.sendButtonVideoRecordingSettings(requestId, width, height, fps)
+                deviceManager.sendButtonVideoRecordingSettings(requestId, defaults.width, defaults.height, defaults.fps)
             },
         )
 
-    fun setButtonVideoRecordingSettings(settings: ButtonVideoRecordingSettings): SettingsAckEvent =
-        setButtonVideoRecordingSettings(width = settings.width, height = settings.height, fps = settings.fps)
-
-    fun setButtonCameraLed(enabled: Boolean): SettingsAckEvent =
-        performSettingsCommand(
-            setting = "button_camera_led",
-            updateStore = { _ -> DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_camera_led", enabled) },
-            send = { requestId -> deviceManager.sendButtonCameraLedSetting(requestId, enabled) },
-        )
-
-    fun setButtonMaxRecordingTime(minutes: Int): SettingsAckEvent =
+    fun setMaxVideoRecordingDuration(minutes: Int): SettingsAckEvent =
         performSettingsCommand(
             setting = "button_max_recording_time",
             updateStore = { _ ->
@@ -574,6 +566,23 @@ class MentraBluetoothSdk private constructor(
         return result
     }
 
+    /**
+     * Configure camera HAL tuning on Mentra Live glasses.
+     *
+     * The phone sends a {@code camera_tuning_config} BLE message; the ASG client relays it as a
+     * {@code camconfig} broadcast to SystemUI's CTReceiver so the camera HAL picks up the new
+     * parameters without a reboot.
+     *
+     * @param anrOn  {@code true} = ANR enabled, {@code false} = ANR disabled (pixsmart param)
+     * @param gainOn {@code true} = stock gain params, {@code false} = pixsmart gain-off params
+     */
+    fun setCameraTuningConfig(anrOn: Boolean, gainOn: Boolean): SettingsAckEvent =
+        performSettingsCommand(
+            setting = "camera_tuning",
+            updateStore = { _ -> },
+            send = { requestId -> deviceManager.sendCameraTuningConfig(requestId, anrOn, gainOn) },
+        )
+
     fun setMicState(
         enabled: Boolean,
         useGlassesMic: Boolean = true,
@@ -623,18 +632,37 @@ class MentraBluetoothSdk private constructor(
 
     fun requestWifiScan(): List<WifiScanResult> {
         val pending = PendingResponse<List<WifiScanResult>>("WiFi scan request")
+        val request = PendingWifiScan(pending)
         synchronized(oneShotLock) {
             if (pendingWifiScan != null) {
-                throw BluetoothException(
+                throw BluetoothSdkException(
                     "request_in_flight",
                     "A WiFi scan is already waiting for a glasses response.",
                 )
             }
-            pendingWifiScan = PendingWifiScan(pending)
+            pendingWifiScan = request
         }
         try {
             deviceManager.requestWifiScan()
             return pending.await()
+        } catch (error: BluetoothSdkException) {
+            if (error.code == "request_timeout") {
+                val fallbackResults =
+                    synchronized(oneShotLock) {
+                        if (request.latestResults.isNotEmpty()) {
+                            if (pendingWifiScan === request) {
+                                pendingWifiScan = null
+                            }
+                            request.latestResults
+                        } else {
+                            emptyList()
+                        }
+                    }
+                if (fallbackResults.isNotEmpty()) {
+                    return fallbackResults
+                }
+            }
+            throw error
         } finally {
             synchronized(oneShotLock) {
                 if (pendingWifiScan?.pending === pending) {
@@ -648,7 +676,7 @@ class MentraBluetoothSdk private constructor(
         val pending = PendingResponse<WifiStatusEvent>("WiFi connect request")
         synchronized(oneShotLock) {
             if (pendingWifiStatus != null) {
-                throw BluetoothException(
+                throw BluetoothSdkException(
                     "request_in_flight",
                     "A WiFi status command is already waiting for a glasses response.",
                 )
@@ -671,7 +699,7 @@ class MentraBluetoothSdk private constructor(
         val pending = PendingResponse<WifiStatusEvent>("WiFi forget request")
         synchronized(oneShotLock) {
             if (pendingWifiStatus != null) {
-                throw BluetoothException(
+                throw BluetoothSdkException(
                     "request_in_flight",
                     "A WiFi status command is already waiting for a glasses response.",
                 )
@@ -694,7 +722,7 @@ class MentraBluetoothSdk private constructor(
         val pending = PendingResponse<HotspotStatusEvent>("hotspot ${if (enabled) "enable" else "disable"} request")
         synchronized(oneShotLock) {
             if (pendingHotspotStatus != null) {
-                throw BluetoothException(
+                throw BluetoothSdkException(
                     "request_in_flight",
                     "A hotspot command is already waiting for a glasses response.",
                 )
@@ -718,16 +746,44 @@ class MentraBluetoothSdk private constructor(
     }
 
     fun requestPhoto(request: PhotoRequest): PhotoResponseEvent {
+        val routedRequest =
+            nonBlankRequestId(request.requestId)
+                ?.let { if (it == request.requestId) request else request.copy(requestId = it) }
+                ?: request.copy(requestId = generatedCameraRequestId("photo"))
         Bridge.log(
-            "NATIVE: PHOTO PIPELINE [3b/6] MentraBluetoothSdk.requestPhoto requestId=${request.requestId} appId=${request.appId}"
+            "NATIVE: PHOTO PIPELINE [3b/6] MentraBluetoothSdk.requestPhoto requestId=${routedRequest.requestId}"
         )
-        val pending = PendingResponse<PhotoResponseEvent>("photo request ${request.requestId}")
-        pendingPhotoRequests[request.requestId] = pending
+        val pending = PendingResponse<PhotoResponseEvent>("photo request ${routedRequest.requestId}")
+        pendingPhotoRequests[routedRequest.requestId] = pending
+        try {
+            deviceManager.requestPhoto(routedRequest)
+            return pending.await()
+        } finally {
+            pendingPhotoRequests.remove(routedRequest.requestId, pending)
+        }
+    }
+
+    fun warmUpCamera(
+        requestId: String? = null,
+        size: PhotoSize,
+        exposureTimeNs: Long?,
+        durationMs: Int,
+    ): CameraStatusEvent {
+        val effectiveRequestId = nonBlankRequestId(requestId) ?: generatedCameraRequestId("warm")
+        val pending = PendingResponse<CameraStatusEvent>("camera warm up $effectiveRequestId")
+        // Guard against a concurrent warm-up reusing the same requestId: a blind put would overwrite
+        // (and strand) the first caller's continuation until it times out. Reject the duplicate.
+        if (pendingCameraStatusRequests.putIfAbsent(effectiveRequestId, pending) != null) {
+            throw BluetoothSdkException(
+                "request_in_flight",
+                "A camera warm-up request with this requestId is already waiting for a glasses response.",
+            )
+        }
         try {
-            deviceManager.requestPhoto(request)
+            deviceManager.warmUpCamera(effectiveRequestId, size, exposureTimeNs, durationMs)
             return pending.await()
         } finally {
-            pendingPhotoRequests.remove(request.requestId, pending)
+            pendingCameraStatusRequests.remove(effectiveRequestId, pending)
         }
     }
 
@@ -735,7 +791,7 @@ class MentraBluetoothSdk private constructor(
         val pending = PendingResponse<GalleryStatusEvent>("gallery status query")
         synchronized(oneShotLock) {
             if (pendingGalleryStatus != null) {
-                throw BluetoothException(
+                throw BluetoothSdkException(
                     "request_in_flight",
                     "A gallery status query is already waiting for a glasses response.",
                 )
@@ -754,7 +810,16 @@ class MentraBluetoothSdk private constructor(
         }
     }
 
-    fun startStream(request: StreamRequest): StreamStatusEvent {
+    fun startStream(request: StreamRequest): StreamStatusEvent =
+        startStream(request, startSdkKeepAlive = true)
+
+    internal fun startExternallyManagedStream(request: StreamRequest): StreamStatusEvent =
+        startStream(request, startSdkKeepAlive = false)
+
+    private fun startStream(
+        request: StreamRequest,
+        startSdkKeepAlive: Boolean,
+    ): StreamStatusEvent {
         val message = request.toMap().toMutableMap()
         val streamId = (message["streamId"] as? String)?.takeIf { it.isNotBlank() }
                 ?: "sdk-${UUID.randomUUID()}"
@@ -765,8 +830,8 @@ class MentraBluetoothSdk private constructor(
         try {
             deviceManager.startStream(message)
             val event = pending.await(STREAM_START_TIMEOUT_MS)
-            if (request.keepAlive && !request.isExternallyManagedKeepAlive()) {
-                startStreamKeepAliveMonitor(streamId, request.keepAliveIntervalSeconds)
+            if (startSdkKeepAlive) {
+                startStreamKeepAliveMonitor(streamId, DEFAULT_STREAM_KEEP_ALIVE_INTERVAL_SECONDS)
             }
             return event
         } finally {
@@ -804,7 +869,7 @@ class MentraBluetoothSdk private constructor(
         }
         synchronized(oneShotLock) {
             if (pendingStreamStop != null) {
-                throw BluetoothException(
+                throw BluetoothSdkException(
                     "request_in_flight",
                     "A stream stop command is already waiting for a glasses response.",
                 )
@@ -830,7 +895,7 @@ class MentraBluetoothSdk private constructor(
         val pending = PendingResponse<VideoRecordingStatusEvent>("start video recording")
         val pendingRequest = PendingVideoRecordingRequest("recording_started", pending)
         if (pendingVideoRecordingRequests.putIfAbsent(request.requestId, pendingRequest) != null) {
-            throw BluetoothException(
+            throw BluetoothSdkException(
                 "request_in_flight",
                 "A video recording command is already waiting for requestId ${request.requestId}.",
             )
@@ -868,7 +933,7 @@ class MentraBluetoothSdk private constructor(
                 waitForUpload = waitForUpload,
             )
         if (pendingVideoRecordingRequests.putIfAbsent(requestId, pendingRequest) != null) {
-            throw BluetoothException(
+            throw BluetoothSdkException(
                 "request_in_flight",
                 "A video recording command is already waiting for requestId $requestId.",
             )
@@ -887,7 +952,7 @@ class MentraBluetoothSdk private constructor(
         val pending = PendingResponse<VersionInfoResult>("version info request")
         synchronized(oneShotLock) {
             if (pendingVersionInfo != null) {
-                throw BluetoothException(
+                throw BluetoothSdkException(
                     "request_in_flight",
                     "A version info request is already waiting for a glasses response.",
                 )
@@ -916,13 +981,13 @@ class MentraBluetoothSdk private constructor(
     fun checkForOtaUpdate(): Boolean {
         val status = getFreshGlassesStatus()
         if (!status.connected) {
-            throw BluetoothException(
+            throw BluetoothSdkException(
                 "glasses_not_connected",
                 "Cannot check OTA update because glasses are not connected.",
             )
         }
         if (status.buildNumber.isBlank()) {
-            throw BluetoothException(
+            throw BluetoothSdkException(
                 "missing_glasses_version",
                 "Cannot check OTA update because glasses build number is unavailable.",
             )
@@ -952,7 +1017,7 @@ class MentraBluetoothSdk private constructor(
         val pending = PendingResponse<OtaQueryResult>(operation)
         synchronized(oneShotLock) {
             if (pendingOtaQuery != null) {
-                throw BluetoothException(
+                throw BluetoothSdkException(
                     "request_in_flight",
                     "An OTA status query is already waiting for a glasses response.",
                 )
@@ -981,7 +1046,7 @@ class MentraBluetoothSdk private constructor(
         val pending = PendingResponse<OtaStartAckEvent>("OTA start command")
         synchronized(oneShotLock) {
             if (pendingOtaStart != null) {
-                throw BluetoothException(
+                throw BluetoothSdkException(
                     "request_in_flight",
                     "An OTA start command is already waiting for a glasses response.",
                 )
@@ -1005,13 +1070,6 @@ class MentraBluetoothSdk private constructor(
 
     internal fun sendOtaQueryStatus(): OtaQueryResult = queryOtaStatus()
 
-    /** Re-run the glasses-side OTA version check after an internal clock-skew recovery. */
-    @JvmSynthetic
-    internal fun retryOtaVersionCheck(): OtaQueryResult =
-        performOtaQuery("OTA version retry") {
-            deviceManager.retryOtaVersionCheck()
-        }
-
     private fun getFreshGlassesStatus(): GlassesStatus {
         val status = getRawGlassesStatus()
         if (!status.connected || status.buildNumber.isNotBlank()) {
@@ -1053,7 +1111,7 @@ class MentraBluetoothSdk private constructor(
         }
 
         if (!status.connected) {
-            throw BluetoothException(
+            throw BluetoothSdkException(
                 "glasses_not_connected",
                 "Cannot check OTA update because glasses disconnected.",
             )
@@ -1081,7 +1139,7 @@ class MentraBluetoothSdk private constructor(
     private fun resolveOtaVersionUrl(status: GlassesStatus): String {
         val deviceUrl = status.otaVersionUrl.trim()
         if (isLegacyAsgOtaStartBuild(status.buildNumber)) {
-            return deviceUrl.ifBlank { OtaManifestDefaults.PROD_OTA_VERSION_URL }
+            return OtaManifestDefaults.LEGACY_PROD_OTA_VERSION_URL
         }
         // SDK consumers are pinned to the manifest built for their SDK version.
         // A future glasses-advertised URL should not silently change that pairing.
@@ -1090,7 +1148,7 @@ class MentraBluetoothSdk private constructor(
 
     private fun isLegacyAsgOtaStartBuild(buildNumber: String): Boolean {
         val parsed = buildNumber.toIntOrNull()
-        return parsed != null && parsed < 100_000
+        return parsed != null && parsed < 39
     }
 
     internal fun sendShutdown() {
@@ -1163,7 +1221,7 @@ class MentraBluetoothSdk private constructor(
         val bluetoothManager = appContext.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager
         val adapter =
             bluetoothManager?.adapter
-                ?: throw BluetoothException(
+                ?: throw BluetoothSdkException(
                     "bluetooth_unsupported",
                     "This phone does not support Bluetooth.",
                 )
@@ -1171,14 +1229,14 @@ class MentraBluetoothSdk private constructor(
             try {
                 adapter.isEnabled
             } catch (error: SecurityException) {
-                throw BluetoothException(
+                throw BluetoothSdkException(
                     "bluetooth_permission_denied",
                     "Allow Bluetooth permission to $operation.",
                     error,
                 )
             }
         if (!enabled) {
-            throw BluetoothException(
+            throw BluetoothSdkException(
                 "bluetooth_powered_off",
                 "Turn on phone Bluetooth to $operation.",
             )
@@ -1186,7 +1244,7 @@ class MentraBluetoothSdk private constructor(
     }
 
     private fun Throwable.toBluetoothError(defaultCode: String): BluetoothError =
-        if (this is BluetoothException) {
+        if (this is BluetoothSdkException) {
             BluetoothError(code, message ?: code, this)
         } else {
             BluetoothError(defaultCode, message ?: toString(), this)
@@ -1273,6 +1331,7 @@ class MentraBluetoothSdk private constructor(
                     data.containsKey("scanComplete") || data.containsKey("scan_complete")
                 val scanComplete =
                     (data["scanComplete"] as? Boolean) ?: (data["scan_complete"] as? Boolean) ?: false
+                updateWifiScanLatestResults(networks)
                 if (scanComplete || !hasCompletionFlag) {
                     handleWifiScanResultsForRequests(networks)
                 }
@@ -1301,6 +1360,11 @@ class MentraBluetoothSdk private constructor(
                 dispatchToListeners { it.onPhotoResponse(event) }
             }
             "photo_status" -> dispatchToListeners { it.onPhotoStatus(PhotoStatusEvent(data)) }
+            "camera_status" -> {
+                val event = CameraStatusEvent(data)
+                handleCameraStatusForRequests(event)
+                dispatchToListeners { it.onCameraStatus(event) }
+            }
             "video_recording_status" -> {
                 val event = VideoRecordingStatusEvent(data)
                 handleVideoRecordingStatusForRequests(event)
@@ -1328,13 +1392,6 @@ class MentraBluetoothSdk private constructor(
                     dispatchToListeners { it.onKeepAliveAck(event) }
                 }
             }
-            "ota_update_available" -> {
-                val resultValues = data + mapOf("type" to "ota_update_available")
-                synchronized(oneShotLock) {
-                    pendingOtaQuery?.resolve(OtaQueryResult(resultValues))
-                }
-                dispatchToListeners { it.onOtaUpdateAvailable(OtaUpdateAvailableEvent.fromMap(resultValues)) }
-            }
             "ota_start_ack" -> {
                 val event = OtaStartAckEvent.fromMap(data + mapOf("type" to "ota_start_ack"))
                 synchronized(oneShotLock) {
@@ -1524,10 +1581,10 @@ class MentraBluetoothSdk private constructor(
             )
         )
 
-    private fun streamStatusException(event: StreamStatusEvent, code: String): BluetoothException {
+    private fun streamStatusException(event: StreamStatusEvent, code: String): BluetoothSdkException {
         val details = (event.status as? StreamStatus.Error)?.errorDetails
             ?: "Stream status ${event.state.value}"
-        return BluetoothException(code, details)
+        return BluetoothSdkException(code, details)
     }
 
     private fun handlePhotoResponseForRequests(event: PhotoResponseEvent) {
@@ -1536,7 +1593,7 @@ class MentraBluetoothSdk private constructor(
             is PhotoResponse.Success -> pending.resolve(event)
             is PhotoResponse.Error ->
                 pending.reject(
-                    BluetoothException(
+                    BluetoothSdkException(
                         response.errorCode ?: "photo_request_failed",
                         response.errorMessage,
                     )
@@ -1544,6 +1601,22 @@ class MentraBluetoothSdk private constructor(
         }
     }
 
+    private fun handleCameraStatusForRequests(event: CameraStatusEvent) {
+        val pending = pendingCameraStatusRequests[event.requestId] ?: return
+        when (event.state.lowercase()) {
+            "ready" -> pending.resolve(event)
+            "error" ->
+                pending.reject(
+                    BluetoothSdkException(
+                        event.errorCode ?: "camera_warm_up_failed",
+                        event.errorMessage ?: "Camera warm-up failed.",
+                    )
+                )
+            // "warming"/"stopped" are progress updates; leave the pending promise alone.
+            else -> {}
+        }
+    }
+
     private fun handleVideoRecordingStatusForRequests(event: VideoRecordingStatusEvent) {
         val request = pendingVideoRecordingRequests[event.requestId] ?: return
         if (event.success) {
@@ -1559,7 +1632,7 @@ class MentraBluetoothSdk private constructor(
             }
         } else {
             request.pending.reject(
-                BluetoothException(
+                BluetoothSdkException(
                     event.status.ifBlank { "video_recording_failed" },
                     event.details ?: "Video recording command failed.",
                 )
@@ -1580,7 +1653,7 @@ class MentraBluetoothSdk private constructor(
             }
         } else {
             request.pending.reject(
-                BluetoothException(
+                BluetoothSdkException(
                     "video_upload_failed",
                     event.errorMessage ?: "Video upload failed.",
                 )
@@ -1594,7 +1667,7 @@ class MentraBluetoothSdk private constructor(
             pending.resolve(event)
         } else {
             pending.reject(
-                BluetoothException(
+                BluetoothSdkException(
                     event.errorCode ?: "rgb_led_control_failed",
                     event.errorCode ?: "RGB LED command failed.",
                 )
@@ -1606,7 +1679,7 @@ class MentraBluetoothSdk private constructor(
         val pending = pendingSettingsRequests[event.requestId] ?: return
         if (isFailureStatus(event.status)) {
             pending.reject(
-                BluetoothException(
+                BluetoothSdkException(
                     event.errorCode ?: "${event.setting.ifBlank { "settings" }}_failed",
                     event.errorMessage ?: "Settings command ${event.setting.ifBlank { event.requestId }} failed.",
                 )
@@ -1629,6 +1702,13 @@ class MentraBluetoothSdk private constructor(
         request.pending.resolve(results)
     }
 
+    private fun updateWifiScanLatestResults(results: List<WifiScanResult>) {
+        if (results.isEmpty()) return
+        synchronized(oneShotLock) {
+            pendingWifiScan?.latestResults = results
+        }
+    }
+
     private fun handleWifiStatusForRequests(event: WifiStatusEvent) {
         val request = synchronized(oneShotLock) { pendingWifiStatus } ?: return
         if (!wifiStatusMatches(event.status, request)) return
@@ -1674,7 +1754,7 @@ class MentraBluetoothSdk private constructor(
             }
         }
         request.pending.reject(
-            BluetoothException(
+            BluetoothSdkException(
                 "hotspot_command_failed",
                 event.message ?: "Hotspot command failed.",
             )

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

@@ -9,14 +9,14 @@ 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"
+    // ASG builds before 39 ignore ota_start.ota_version_url, so SDK checks must
+    // use the same legacy production manifest those glasses will install from.
+    const val LEGACY_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(
+            throw BluetoothSdkException(
                 "missing_sdk_version",
                 "Cannot determine Bluetooth SDK version for the default OTA manifest URL.",
             )
@@ -31,19 +31,19 @@ internal object OtaManifestChecker {
     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.")
+            throw BluetoothSdkException("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)
+                throw BluetoothSdkException("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.")
+            throw BluetoothSdkException("invalid_ota_url", "OTA version URL must be an http(s) URL.")
         }
 
         return uri.toString()
@@ -57,7 +57,7 @@ internal object OtaManifestChecker {
         return try {
             val status = connection.responseCode
             if (status !in 200..299) {
-                throw BluetoothException("ota_manifest_request_failed", "OTA manifest request failed with HTTP $status.")
+                throw BluetoothSdkException("ota_manifest_request_failed", "OTA manifest request failed with HTTP $status.")
             }
             JSONObject(connection.inputStream.bufferedReader().use { it.readText() })
         } finally {
@@ -92,13 +92,13 @@ internal object OtaManifestChecker {
             return manifest
         }
 
-        throw BluetoothException("invalid_ota_manifest", "OTA manifest is missing ASG app versionCode.")
+        throw BluetoothSdkException("invalid_ota_manifest", "OTA manifest is missing ASG app versionCode.")
     }
 
     private fun hasApkUpdate(currentBuildNumber: String, manifest: JSONObject): Boolean {
         val currentVersion =
             currentBuildNumber.toLongOrNull()
-                ?: throw BluetoothException(
+                ?: throw BluetoothSdkException(
                     "invalid_glasses_version",
                     "Cannot check OTA update because glasses build number is invalid.",
                 )
@@ -124,7 +124,7 @@ internal object OtaManifestChecker {
         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.")
+            throw BluetoothSdkException("invalid_ota_manifest", "OTA manifest bes_firmware.version is missing.")
         }
         if (currentVersion.isBlank()) return true
         return compareVersions(serverVersion, currentVersion) > 0
@@ -149,5 +149,5 @@ internal object OtaManifestChecker {
 
     private fun JSONObject.requiredLong(key: String): Long =
         (opt(key) as? Number)?.toLong()
-            ?: throw BluetoothException("invalid_ota_manifest", "OTA manifest is missing ASG app versionCode.")
+            ?: throw BluetoothSdkException("invalid_ota_manifest", "OTA manifest is missing ASG app versionCode.")
 }