@mentra/bluetooth-sdk 0.1.12 → 0.1.14

package/README.md

@@ -325,7 +325,7 @@ React Native narrows returned values to success shapes where the raw listener ev
 | `startVideoRecording(...)` | `VideoRecordingStartedStatusEvent` with `success: true` and `status: "recording_started"`. | Rejects on `success: false` statuses such as `already_recording`, send failure, or timeout. |
 | `stopVideoRecording(...)` | `VideoRecordingStoppedStatusEvent` with `success: true` and `status: "recording_stopped"`. When a webhook URL is supplied, resolves after the video upload succeeds. | Rejects on `success: false` statuses such as `not_recording`, webhook upload failure, send failure, or timeout. |
 | `rgbLedControl(...)` | `RgbLedControlSuccessResponseEvent` with `state: "success"`. | Rejects when raw `rgb_led_control_response.state === "error"` or the response times out. |
-| `checkForOtaUpdate()` / `retryOtaVersionCheck()` | `OtaQueryResult`, either `ota_update_available` or current `ota_status`. | Rejects on command transport timeout/failure. A returned `ota_status.status === "failed"` is glasses OTA state, not a command rejection. |
+| `checkForOtaUpdate()` | `boolean`, true when the configured OTA manifest has an ASG APK, MTK, or BES update for the connected glasses; false only when the manifest was checked successfully and no update is available. | Rejects when the glasses are disconnected, version info is unavailable, the manifest cannot be fetched, or the manifest response is invalid/missing required ASG app version fields. |
 
 Android and iOS async APIs use `BluetoothException` / `BluetoothError` for the same error paths. Their returned event structs are the successful response in normal `try`/`await` code, while raw listener/delegate events still include both success and error payloads.
 
@@ -335,9 +335,16 @@ Android and iOS async APIs use `BluetoothException` / `BluetoothError` for the s
 
 Mentra Live firmware owns the OTA flow. The SDK mirrors the MentraOS app commands and events:
 
-- `checkForOtaUpdate()` sends `ota_query_status` and resolves with the ASG response (`ota_update_available` or the current `ota_status`).
-- `startOtaUpdate()` sends `ota_start` and resolves with the ASG start ack after your app presents the update and the user accepts it.
-- `retryOtaVersionCheck()` sends `ota_retry_version_check` and resolves with the same ASG response shape as `checkForOtaUpdate()`; use it only after fixing a known clock-skew/TLS failure.
+- `checkForOtaUpdate()` fetches the configured manifest and resolves with `true` when an ASG APK, MTK, or BES update is available.
+- `startOtaUpdate()` sends `ota_start` with the same configured manifest URL and resolves with the ASG start ack after your app presents the update and the user accepts it.
+
+The default manifest is derived from the SDK version:
+`https://github.com/Mentra-Community/MentraOS/releases/download/bluetooth-sdk-ota/bluetooth-sdk-<sdkVersion>-version.json`.
+Each published SDK version points at a durable ASG client APK and firmware
+manifest that were built for that SDK release. Pre-wall-clock ASG builds that
+ignore `ota_start.ota_version_url` are checked against the URL they advertise,
+or the production default if they do not advertise one, so the app does not
+prompt for an update the glasses cannot install.
 
 ```ts
 import BluetoothSdk from '@mentra/bluetooth-sdk'
@@ -346,9 +353,9 @@ BluetoothSdk.addListener('ota_status', (event) => {
   console.log(`OTA ${event.status}: ${event.overall_percent}%`)
 })
 
-const ota = await BluetoothSdk.checkForOtaUpdate()
-if (ota.type === 'ota_update_available') {
-  const userAccepted = await promptUserToInstallUpdate(ota) // your app's UI
+const hasUpdate = await BluetoothSdk.checkForOtaUpdate()
+if (hasUpdate) {
+  const userAccepted = await promptUserToInstallUpdate() // your app's UI
   if (userAccepted) {
     const startAck = await BluetoothSdk.startOtaUpdate()
     console.log('OTA start acknowledged', startAck.timestamp)
@@ -398,8 +405,8 @@ await BluetoothSdk.startStream({
 await BluetoothSdk.stopStream()
 ```
 
-Use `rtmp://` or `rtmps://` for RTMP, `srt://` for SRT, and `http://` or `https://` for WHIP/WebRTC ingest. `startStream()` resolves with the correlated `stream_status` event once the glasses report `status: "streaming"`; `stopStream()` resolves when the glasses report `status: "stopped"` or confirms the stream was already stopped / not streaming. `stopStream()` returns a normalized stopped event for that already-stopped case. Stream starts reject if the glasses report an error before streaming; stream stops reject for real stop errors, send failure, another stop in flight, or timeout. The SDK sends stream keep-alives automatically while streaming and reports keep-alive failures through `stream_status`. The camera light is always enabled while streaming.
-`stream_status` events may include `resolvedConfig`, which reports the effective transport, video, and audio settings after glasses defaults, clamps, and camera preflight.
+Use `rtmp://` or `rtmps://` for RTMP, `srt://` for SRT, and `http://` or `https://` for WHIP/WebRTC ingest. `startStream()` resolves with the correlated `stream_status` event once the glasses report `status: "streaming"`; `stopStream()` resolves when the glasses report `status: "stopped"` or confirms the stream was already stopped / not streaming. `stopStream()` returns a normalized stopped event for that already-stopped case. Stream starts reject if the glasses report an error before streaming; stream stops reject for real stop errors, send failure, another stop in flight, or timeout. Stream video input fields are `width`, `height`, `bitrate`, and `fps`. The SDK sends stream keep-alives automatically while streaming and reports keep-alive failures through `stream_status`. The camera light is always enabled while streaming.
+`stream_status` events may include `resolvedConfig`, which reports the effective transport, video, and audio settings after glasses defaults, clamps, and camera preflight. The resolved effective frame rate is reported as `resolvedConfig.video.fps`.
 
 ## Events
 
@@ -425,7 +432,7 @@ export function HardwareEventLogger() {
 
 For non-React modules, `BluetoothSdk.addListener(...)` is the low-level subscription API. Keep the returned subscription and call `remove()` when the listener is no longer needed.
 
-Common event names include `button_press`, `touch_event`, `head_up`, `battery_status`, `wifi_status_change`, `wifi_scan_result`, `hotspot_status_change`, `photo_status`, `photo_response`, `gallery_status`, `settings_ack`, `version_info`, `stream_status`, `ota_update_available`, `ota_start_ack`, `ota_status`, `mic_pcm`, `mic_lc3`, `local_transcription`, `rgb_led_control_response`, `audio_connected`, `audio_disconnected`, and `log`.
+Common event names include `button_press`, `touch_event`, `head_up`, `battery_status`, `wifi_status_change`, `wifi_scan_result`, `hotspot_status_change`, `photo_status`, `photo_response`, `gallery_status`, `settings_ack`, `version_info`, `stream_status`, `ota_start_ack`, `ota_status`, `mic_pcm`, `mic_lc3`, `local_transcription`, `rgb_led_control_response`, `audio_connected`, `audio_disconnected`, and `log`.
 
 React Native event payload fields usually use camelCase. OTA events intentionally mirror the glasses firmware field names, such as `overall_percent` and `version_name`. For example, `touch_event` includes `gestureName`, `wifi_scan_result` includes `networks` and `scanComplete`, `version_info` matches the `requestVersionInfo()` result shape, `photo_response` success includes `uploadUrl` and may include webhook-returned `photoUrl`, `statusUrl`, `contentType`, and `fileSizeBytes`, and `gallery_status` includes `hasContent`, `cameraBusy`, and optional `cameraBusyReason`. `photo_status` reports intermediate photo states such as `accepted`, `queued`, `configuring`, `capturing`, `captured`, `compressing`, `ble_fallback_compression`, `uploading`, `ready_for_transfer`, `transferring`, and `failed`; the `configuring` event includes `resolvedConfig` with the effective JPEG dimensions, quality, requested size, transfer method, compression, and manual exposure fields when present. The `capturing` event may include `requestedCaptureConfig` and `meteredPreview`; the `captured` event may include `captureMetadata` with the HAL-applied exposure, ISO, frame duration, and AE state. `mic_pcm` includes `sampleRate`, `bitsPerSample`, `channels`, and `encoding`; `mic_lc3` includes `sampleRate`, `channels`, `encoding`, `frameDurationMs`, `frameSizeBytes`, `bitrate`, and `packetizedFromGlasses`.
 
@@ -452,13 +459,25 @@ MENTRA_BLUETOOTH_SDK_PACKAGE_PATH=/path/to/MentraOS/mobile/modules/bluetooth-sdk
 
 Use `bunx expo run:android` for Android. Keep local paths in your shell or CI environment, not in committed app config.
 
+For local Android source compile checks inside this monorepo, run from the
+MentraOS repo root:
+
+```sh
+./scripts/check-android-compile.sh bluetooth-sdk
+```
+
+The `android/` folder in this package is source for the generated Expo Android
+project, not the local Gradle entrypoint. The check script prepares
+`mobile/android` and uses its Gradle wrapper with `-PmentraPublicSdk=true`,
+matching the CI release workflow's public SDK dependency mode.
+
 For bare native iOS apps, use the public SwiftPM repository:
 
 ```text
 https://github.com/Mentra-Community/mentra-bluetooth-sdk-ios.git
 ```
 
-Add the `MentraBluetoothSDK` product to your app target at version `0.1.12` or newer.
+Select version `0.1.14`, then add the `MentraBluetoothSDK` product to your app target.
 
 For local SDK development, add this package folder directly in Xcode:
 

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

@@ -441,20 +441,16 @@ class BluetoothSdkModule : Module() {
             sdk?.setVoiceActivityDetectionEnabled(enabled)
         }
 
-        AsyncFunction("setButtonPhotoSettings") { size: String ->
-            requireSdk().setButtonPhotoSettings(ButtonPhotoSize.fromValue(size)).values
+        AsyncFunction("setPhotoCaptureDefaults") { params: Map<String, Any?> ->
+            requireSdk().setPhotoCaptureDefaults(params.toPhotoCaptureDefaults()).values
         }
 
-        AsyncFunction("setButtonVideoRecordingSettings") { width: Int, height: Int, fps: Int ->
-            requireSdk().setButtonVideoRecordingSettings(width, height, fps).values
+        AsyncFunction("setVideoRecordingDefaults") { width: Int, height: Int, fps: Int ->
+            requireSdk().setVideoRecordingDefaults(VideoRecordingDefaults(width, height, fps)).values
         }
 
-        AsyncFunction("setButtonCameraLed") { enabled: Boolean ->
-            requireSdk().setButtonCameraLed(enabled).values
-        }
-
-        AsyncFunction("setButtonMaxRecordingTime") { minutes: Int ->
-            requireSdk().setButtonMaxRecordingTime(minutes).values
+        AsyncFunction("setMaxVideoRecordingDuration") { minutes: Int ->
+            requireSdk().setMaxVideoRecordingDuration(minutes).values
         }
 
         AsyncFunction("setCameraFov") { fov: Map<String, Any> ->
@@ -476,14 +472,33 @@ class BluetoothSdkModule : Module() {
                     }.toMap()
             val req = PhotoRequest.fromMap(sanitized)
             Bridge.log(
-                    "NATIVE: PHOTO PIPELINE [3/6] BluetoothSdk.requestPhoto requestId=${req.requestId} appId=${req.appId} size=${req.size} compress=${req.compress} flash=${req.flash} sound=${req.sound} exposureTimeNs=${req.exposureTimeNs} iso=${req.iso}"
+                    "NATIVE: PHOTO PIPELINE [3/6] BluetoothSdk.requestPhoto requestId=${req.requestId} appId=${req.appId} size=${req.size} compress=${req.compress} sound=${req.sound} exposureTimeNs=${req.exposureTimeNs} iso=${req.iso}"
             )
             requireSdk().requestPhoto(req).values
         }
 
         // MARK: - OTA Commands
 
-        AsyncFunction("sendOtaStart") { requireSdk().sendOtaStart().values }
+        Function("setOtaVersionUrl") { otaVersionUrl: String ->
+            requireSdk().setOtaVersionUrl(otaVersionUrl)
+        }
+
+        Function("getOtaVersionUrl") { requireSdk().getOtaVersionUrl() }
+
+        // Runs on Dispatchers.IO, not the shared Expo AsyncFunctionQueue:
+        // manifest fetches and version waits can block for several seconds.
+        AsyncFunction("checkForOtaUpdate") Coroutine { ->
+            withContext(Dispatchers.IO) { requireSdk().checkForOtaUpdate() }
+        }
+
+        AsyncFunction("startOtaUpdate") { otaVersionUrl: String? ->
+            val sdk = requireSdk()
+            if (otaVersionUrl.isNullOrBlank()) {
+                sdk.startOtaUpdate().values
+            } else {
+                sdk.startOtaUpdate(otaVersionUrl).values
+            }
+        }
 
         AsyncFunction("sendOtaQueryStatus") { requireSdk().sendOtaQueryStatus().values }
 
@@ -538,6 +553,10 @@ class BluetoothSdkModule : Module() {
             requireSdk().startStream(StreamRequest.fromMap(params)).values
         }
 
+        AsyncFunction("startExternallyManagedStream") { params: Map<String, Any> ->
+            requireSdk().startExternallyManagedStream(StreamRequest.fromMap(params)).values
+        }
+
         AsyncFunction("stopStream") { requireSdk().stopStream().values }
 
         AsyncFunction("sendExternallyManagedStreamKeepAlive") { params: Map<String, Any> ->
@@ -727,6 +746,22 @@ private fun Map<String, Any>?.toMentraDevice(): Device? {
     )
 }
 
+private fun Map<String, Any?>.toPhotoCaptureDefaults(): PhotoCaptureDefaults =
+        PhotoCaptureDefaults(
+                size = (this["size"] as? String)?.let { PhotoSize.fromValue(it) },
+                mfnr = this["mfnr"] as? Boolean,
+                zsl = this["zsl"] as? Boolean,
+                noiseReduction = this["noiseReduction"] as? Boolean,
+                edgeEnhancement = this["edgeEnhancement"] as? Boolean,
+                ispDigitalGain = (this["ispDigitalGain"] as? Number)?.toInt(),
+                ispAnalogGain = this["ispAnalogGain"] as? String,
+                aeExposureDivisor = (this["aeExposureDivisor"] as? Number)?.toInt(),
+                isoCap = (this["isoCap"] as? Number)?.toInt(),
+                compress = this["compress"] as? String,
+                sound = this["sound"] as? Boolean,
+                resetCaptureTuning = this["resetCaptureTuning"] as? Boolean == true,
+        )
+
 private fun Map<String, Any>?.toMentraConnectOptions(): ConnectOptions {
     val values = this ?: return ConnectOptions()
     return ConnectOptions(

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

@@ -247,6 +247,7 @@ class DeviceManager {
     private var audioOutputFormat: AudioOutputFormat = AudioOutputFormat.LC3
     private var lastLc3Event: Long? = null
     private var micReinitRunnable: Runnable? = null
+    private var systemMicAvailabilityRecheckRunnable: Runnable? = null
 
     // VAD
     private val vadBuffer = mutableListOf<ByteArray>()
@@ -358,6 +359,37 @@ class DeviceManager {
         }
     }
 
+    private fun scheduleSystemMicAvailabilityRecheck(reason: String) {
+        if (systemMicAvailabilityRecheckRunnable != null) {
+            return
+        }
+
+        val recheck =
+                object : Runnable {
+                    override fun run() {
+                        systemMicAvailabilityRecheckRunnable = null
+
+                        if (!micEnabled || !systemMicUnavailable) {
+                            return
+                        }
+
+                        val stillBlocked = phoneMic?.hasBlockingMicInterruption() ?: true
+                        if (stillBlocked) {
+                            scheduleSystemMicAvailabilityRecheck(reason)
+                            return
+                        }
+
+                        systemMicUnavailable = false
+                        Bridge.log("MAN: MIC_UNAVAILABLE: FALSE recheck_after_$reason")
+                        appendLog("MAN: MIC_UNAVAILABLE: FALSE recheck_after_$reason")
+                        updateMicState()
+                    }
+                }
+
+        systemMicAvailabilityRecheckRunnable = recheck
+        mainHandler.postDelayed(recheck, 2_000)
+    }
+
     // MARK: - Unique (Android)
     private fun setupPermissionMonitoring() {
         val context = Bridge.getContext()
@@ -947,6 +979,7 @@ class DeviceManager {
                 systemMicUnavailable = true
                 Bridge.log("MAN: MIC_UNAVAILABLE: TRUE external_app_recording")
                 appendLog("MAN: MIC_UNAVAILABLE: TRUE external_app_recording")
+                scheduleSystemMicAvailabilityRecheck("external_app_recording")
             }
             "audio_focus_available" -> {
                 // Audio focus is available again
@@ -965,6 +998,7 @@ class DeviceManager {
                 systemMicUnavailable = true
                 Bridge.log("MAN: MIC_UNAVAILABLE: TRUE phone_call_interruption")
                 appendLog("MAN: MIC_UNAVAILABLE: TRUE phone_call_interruption")
+                scheduleSystemMicAvailabilityRecheck("phone_call_interruption")
             }
             "phone_call_ended" -> {
                 // Phone call ended - mark mic as available again
@@ -977,12 +1011,14 @@ class DeviceManager {
                 systemMicUnavailable = true
                 Bridge.log("MAN: MIC_UNAVAILABLE: TRUE phone_call_active")
                 appendLog("MAN: MIC_UNAVAILABLE: TRUE phone_call_active")
+                scheduleSystemMicAvailabilityRecheck("phone_call_active")
             }
             "audio_focus_denied" -> {
                 // Another app has audio focus
                 systemMicUnavailable = true
                 Bridge.log("MAN: MIC_UNAVAILABLE: TRUE audio_focus_denied")
                 appendLog("MAN: MIC_UNAVAILABLE: TRUE audio_focus_denied")
+                scheduleSystemMicAvailabilityRecheck("audio_focus_denied")
             }
             "permission_denied" -> {
                 // Microphone permission not granted
@@ -1010,6 +1046,9 @@ class DeviceManager {
                 // systemMicUnavailable = false
                 Bridge.log("MAN: MIC_UNAVAILABLE: UNKNOWN recording_stopped")
                 appendLog("MAN: MIC_UNAVAILABLE: UNKNOWN recording_stopped")
+                if (systemMicUnavailable) {
+                    scheduleSystemMicAvailabilityRecheck("recording_stopped")
+                }
             }
             else -> {
                 // Other route changes (headset plug/unplug, BT connect/disconnect, etc.)
@@ -1326,7 +1365,6 @@ class DeviceManager {
 
     fun startStream(message: MutableMap<String, Any>) {
         Bridge.log("MAN: startStream")
-        message["flash"] = true
         sgc?.startStream(message)
     }
 
@@ -1380,9 +1418,9 @@ class DeviceManager {
      * Send OTA start command to glasses. Called when user approves an update (onboarding or
      * background mode). Triggers glasses to begin download and installation.
      */
-    fun sendOtaStart() {
+    fun sendOtaStart(otaVersionUrl: String? = null) {
         Bridge.log("MAN: 📱 Sending OTA start command to glasses")
-        (sgc as? MentraLive)?.sendOtaStart()
+        (sgc as? MentraLive)?.sendOtaStart(otaVersionUrl)
     }
 
     fun sendOtaQueryStatus() {
@@ -1396,18 +1434,31 @@ class DeviceManager {
     }
 
     fun sendButtonPhotoSettings(requestId: String, size: String) {
-        val live = sgc as? MentraLive ?: throw IllegalStateException("unsupported_device")
-        live.sendButtonPhotoSettings(requestId, size)
+        sendButtonPhotoSettings(requestId, PhotoCaptureDefaults(PhotoSize.fromValue(size)))
     }
 
-    fun sendButtonVideoRecordingSettings(requestId: String, width: Int, height: Int, fps: Int) {
+    fun sendButtonPhotoSettings(requestId: String, settings: PhotoCaptureDefaults) {
         val live = sgc as? MentraLive ?: throw IllegalStateException("unsupported_device")
-        live.sendButtonVideoRecordingSettings(requestId, width, height, fps)
+        live.sendButtonPhotoSettings(
+            requestId,
+            settings.size?.value,
+            settings.mfnr,
+            settings.zsl,
+            settings.noiseReduction,
+            settings.edgeEnhancement,
+            settings.ispDigitalGain,
+            settings.ispAnalogGain,
+            settings.aeExposureDivisor,
+            settings.isoCap,
+            settings.compress,
+            settings.sound,
+            settings.resetCaptureTuning == true,
+        )
     }
 
-    fun sendButtonCameraLedSetting(requestId: String, enabled: Boolean) {
+    fun sendButtonVideoRecordingSettings(requestId: String, width: Int, height: Int, fps: Int) {
         val live = sgc as? MentraLive ?: throw IllegalStateException("unsupported_device")
-        live.sendButtonCameraLedSetting(requestId, enabled)
+        live.sendButtonVideoRecordingSettings(requestId, width, height, fps)
     }
 
     fun sendButtonMaxRecordingTime(requestId: String, minutes: Int) {
@@ -1508,11 +1559,11 @@ class DeviceManager {
             maxRecordingTimeMinutes: Int = 0,
     ) {
         Bridge.log(
-                "MAN: onStartVideoRecording: requestId=$requestId, save=$save, flash=true, sound=$sound, " +
+                "MAN: onStartVideoRecording: requestId=$requestId, save=$save, sound=$sound, " +
                         "resolution=${width}x${height}@${fps}fps, maxRecordingTimeMinutes=$maxRecordingTimeMinutes"
         )
         sgc?.startVideoRecording(
-                requestId, save, true, sound, width, height, fps, maxRecordingTimeMinutes)
+                requestId, save, sound, width, height, fps, maxRecordingTimeMinutes)
     }
 
     fun stopVideoRecording(requestId: String, webhookUrl: String?, authToken: String?) {
@@ -1538,38 +1589,31 @@ class DeviceManager {
         updateMicState()
     }
 
-    fun requestPhoto(
-            requestId: String,
-            appId: String,
-            size: String,
-            webhookUrl: String,
-            authToken: String?,
-            compress: String,
-            flash: Boolean,
-            save: Boolean,
-            sound: Boolean,
-            exposureTimeNs: Double? = null,
-            iso: Int? = null,
-    ) {
+    fun requestPhoto(request: PhotoRequest) {
         val exposureNs: Long? =
-                exposureTimeNs?.takeIf { it.isFinite() && it > 0 }?.let { v ->
+                request.exposureTimeNs?.takeIf { it.isFinite() && it > 0 }?.let { v ->
                     when {
                         v > Long.MAX_VALUE.toDouble() -> Long.MAX_VALUE
                         else -> v.toLong()
                     }
                 }
-        val manualIso = if (exposureNs != null) iso?.takeIf { it > 0 } else null
+        val manualIso = if (exposureNs != null) request.iso?.takeIf { it > 0 } else null
+        val routed =
+                request.copy(
+                        exposureTimeNs = exposureNs?.toDouble(),
+                        iso = manualIso,
+                )
         Bridge.log(
-                "MAN: PHOTO PIPELINE [4/6] DeviceManager.requestPhoto requestId=$requestId appId=$appId size=$size compress=$compress flash=$flash save=$save sound=$sound exposureTimeNs=$exposureNs iso=${manualIso ?: "auto"} sgc=${sgc?.javaClass?.simpleName ?: "null"}"
+                "MAN: PHOTO PIPELINE [4/6] DeviceManager.requestPhoto requestId=${routed.requestId} appId=${routed.appId} size=${routed.size.value} compress=${routed.compress.value} save=${routed.save} sound=${routed.sound} exposureTimeNs=$exposureNs iso=${manualIso ?: "auto"} aeDivisor=${routed.aeExposureDivisor} isoCap=${routed.isoCap} sgc=${sgc?.javaClass?.simpleName ?: "null"}"
         )
         val activeSgc = sgc
         if (activeSgc == null) {
             Bridge.log(
-                    "MAN: PHOTO PIPELINE — sgc is null (glasses not connected); dropping requestId=$requestId"
+                    "MAN: PHOTO PIPELINE — sgc is null (glasses not connected); dropping requestId=${routed.requestId}"
             )
             return
         }
-        activeSgc.requestPhoto(requestId, appId, size, webhookUrl, authToken, compress, flash, save, sound, exposureNs, manualIso)
+        activeSgc.requestPhoto(routed)
     }
 
     fun rgbLedControl(
@@ -1781,6 +1825,8 @@ class DeviceManager {
 
         micReinitRunnable?.let { mainHandler.removeCallbacks(it) }
         micReinitRunnable = null
+        systemMicAvailabilityRecheckRunnable?.let { mainHandler.removeCallbacks(it) }
+        systemMicAvailabilityRecheckRunnable = null
 
         // Clean up transcriber resources
         transcriber?.shutdown()

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

@@ -126,8 +126,7 @@ object DeviceStore {
         store.set("bluetooth", "gallery_mode", true)
         store.set("bluetooth", "voice_activity_detection_enabled", BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED)
         store.set("bluetooth", "screen_disabled", false)
-        store.set("bluetooth", "button_photo_size", "medium")
-        store.set("bluetooth", "button_camera_led", true)
+        store.set("bluetooth", "button_photo_size", "max")
         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)
@@ -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()
             }