@mentra/bluetooth-sdk 3.2.0-dev.265 → 3.2.1-beta.312

package/README.md

@@ -478,6 +478,34 @@ await sdk.setDashboardContent("")
 
 Settings commands that return `SettingsAckSuccessEvent` reject when the ASG reports an error ack. The SDK updates its local settings store only after that ASG ack resolves successfully, so observed SDK state reflects the acknowledged glasses state rather than a queued request. Raw `settings_ack` listener events still use `SettingsAckEvent` because they can include both success and failure statuses. `rgbLedControl(...)` resolves from a successful ASG `rgb_led_control_response` and rejects when the ASG reports `state: "error"`; raw `settings_ack` and `rgb_led_control_response` events remain available through listeners.
 
+### Persistent HTTP gallery server (Mentra Live)
+
+Use `setGalleryServerEnabled(true)` to keep the existing camera/gallery HTTP server available over the Wi-Fi network the glasses have already joined. This opt-in defaults off and persists across BLE reconnects and glasses restarts until explicitly disabled. It has no idle timeout and does not start or join a hotspot.
+
+**This server uses HTTP without authentication. Any client that can reach the glasses can use the full camera/gallery API, including capture and deletion, while it is enabled.** Use it only where your network policy permits that access.
+
+```ts
+const server = await BluetoothSdk.setGalleryServerEnabled(true)
+if (server.listening && server.url) {
+  const gallery = await fetch(`${server.url}/api/gallery`).then((response) => response.json())
+  console.log(gallery)
+  // Download using /api/download?file=<URL-encoded gallery filename>.
+}
+
+// Leave enabled for persistent access, or explicitly turn it off:
+await BluetoothSdk.setGalleryServerEnabled(false)
+```
+
+Native Swift: `try await sdk.setGalleryServerEnabled(true)`; Kotlin: `sdk.setGalleryServerEnabled(true)`. Both return `SettingsAckEvent`, with `enabled`, `listening`, and `url` properties. React Native returns `SettingsAckSuccessEvent` with the same fields.
+
+The acknowledgement confirms the saved setting. `enabled:true, listening:false` means the setting is enabled but no station endpoint is currently available, for example before Wi-Fi connects or while a bind is being retried. `url` is present only when the server is running and station Wi-Fi has an address. Repeat the same enable call to obtain a fresh endpoint without restarting a healthy server.
+
+The same server listens on port 8089 on all local interfaces in persistent mode. Its complete HTTP API is unchanged: listing, downloads, sync, deletion, restore, camera control, and browser UI all work as on the hotspot. Existing response formats, resumable downloads, and in-progress-media filtering remain intact. No HTTP client changes are needed beyond choosing the site-network URL.
+
+Disabling restores normal hotspot-only behavior: the server rebinds to an active hotspot address or stops if no hotspot is active. Changing binding modes can interrupt in-flight requests, so switch modes between transfers or retry interrupted requests.
+
+Both the native SDK and ASG client need this command; older glasses firmware times out without claiming success. The client app must have local-network access and permit cleartext HTTP to the local device under its platform/MDM policy.
+
 WiFi, hotspot, and version-info commands resolve from the ASG response path, not local dispatch:
 `requestWifiScan()` resolves from the ASG `wifi_scan_result` completion response with the updated scan list, including `[]` when no networks are found. Intermediate `wifi_scan_result` events can arrive with `scanComplete: false` while the glasses stream discovered networks; the final event uses `scanComplete: true`. If older glasses stream non-empty scan results but never send the completion event, the request resolves with the accumulated scan list when the request times out. `sendWifiCredentials()` resolves when the requested SSID is connected, `forgetWifiNetwork()` returns a semantic `WifiForgetResult`, `getSavedWifiNetworks()` returns a semantic `SavedWifiNetworksResult`, `setHotspotState()` resolves when the requested hotspot state is reported, and `requestVersionInfo()` waits for all chunks declared by the correlated response's `chunkCount`, `chunkIndex`, and `final` metadata. Legacy single-message responses complete immediately; legacy chunked responses complete on `version_info_3` after `version_info_1`. Missing final chunks time out rather than returning partial data after a quiet period.
 

package/android/lc3Lib/build.gradle

@@ -88,6 +88,11 @@ android {
     namespace "com.mentra.lc3Lib"
     compileSdk 33
 
+    // Reuse the host's NDK instead of downloading AGP's default alongside it.
+    if (rootProject.ext.has('ndkVersion')) {
+        ndkVersion rootProject.ext.ndkVersion
+    }
+
     publishing {
         singleVariant("release") {
             withSourcesJar()

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

@@ -368,6 +368,10 @@ class BluetoothSdkModule : Module() {
             "receive_command_from_ble",
             "swipe_volume_status",
             "switch_status",
+            "mic_tuning_state",
+            "mic_rms",
+            "wear_state",
+            "wear_tuning",
             "rgb_led_control_response",
             "settings_ack",
             "version_info",
@@ -582,6 +586,33 @@ class BluetoothSdkModule : Module() {
         // Stub on Android — iOS uses this for the jetsam stress test.
         Function("getMemoryMB") { -> 0.0 }
 
+        // MARK: - Mic tuning (internal SDK surface only)
+
+        AsyncFunction("setMicRmsTelemetry") { enabled: Boolean ->
+            deviceManager?.sgc?.setMicRmsTelemetry(enabled)
+        }
+
+        // Fire-and-forget: the answer arrives as a mic_tuning_state event, which
+        // the screen is subscribed to anyway.
+        AsyncFunction("requestMicTuningState") { deviceManager?.sgc?.requestMicTuningState() }
+
+        // MARK: - Wear detection (internal SDK surface only)
+
+        // All fire-and-forget; answers arrive as wear_state / wear_tuning events.
+        AsyncFunction("queryWearState") { deviceManager?.queryWearState() }
+
+        AsyncFunction("setWearReporting") { enabled: Boolean ->
+            deviceManager?.setWearReporting(enabled)
+        }
+
+        AsyncFunction("setWearTuning") { intervalMs: Int, count: Int, majority: Int ->
+            deviceManager?.setWearTuning(intervalMs, count, majority)
+        }
+
+        AsyncFunction("requestWearTuning") { deviceManager?.requestWearTuning() }
+
+        AsyncFunction("resetWearTuning") { deviceManager?.resetWearTuning() }
+
         // MARK: - Incident Reporting
 
         SdkAsyncFunction("sendIncidentId") { incidentId: String, apiBaseUrl: String? ->
@@ -629,6 +660,10 @@ class BluetoothSdkModule : Module() {
 
         // MARK: - Gallery Commands
 
+        SdkCoroutineFunction("setGalleryServerEnabled") { enabled: Boolean ->
+            requireSdk().setGalleryServerEnabled(enabled).values
+        }
+
         SdkCoroutineFunction("setGalleryModeEnabled") { enabled: Boolean ->
             requireSdk().setGalleryModeEnabled(enabled).values
         }

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

@@ -391,6 +391,40 @@ public class Bridge private constructor() {
             sendTypedMessage("switch_status", body)
         }
 
+        /**
+         * Mic tuning values the glasses report as actually in force (post-clamp),
+         * from sr_mictun / sr_micst.
+         */
+        @JvmStatic
+        fun sendMicTuningState(state: Map<String, Any>) {
+            sendTypedMessage("mic_tuning_state", HashMap(state))
+        }
+
+        /** Wear state from sr_wrst, or from a wear transition on the glasses. */
+        @JvmStatic
+        fun sendWearState(worn: Boolean) {
+            val body = HashMap<String, Any>()
+            body["worn"] = worn
+            sendTypedMessage("wear_state", body)
+        }
+
+        /** Wear vote config the glasses report as in force, from sr_weartun. */
+        @JvmStatic
+        fun sendWearTuningState(state: Map<String, Any>) {
+            sendTypedMessage("wear_tuning", HashMap(state))
+        }
+
+        /** Disposable mic RMS sample from sr_micrms. */
+        @JvmStatic
+        fun sendMicRms(rms: Int, gateOpen: Boolean, speakerElevated: Boolean, generation: Int) {
+            val body = HashMap<String, Any>()
+            body["rms"] = rms
+            body["gateOpen"] = gateOpen
+            body["speakerElevated"] = speakerElevated
+            body["generation"] = generation
+            sendTypedMessage("mic_rms", body)
+        }
+
         @JvmStatic
         fun sendPhotoError(requestId: String, errorCode: String, errorMessage: String) {
             val timestamp = System.currentTimeMillis()

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

@@ -1883,6 +1883,31 @@ class DeviceManager {
         sgc?.dbg2()
     }
 
+    fun queryWearState() {
+        Bridge.log("MAN: queryWearState()")
+        sgc?.queryWearState()
+    }
+
+    fun setWearReporting(enabled: Boolean) {
+        Bridge.log("MAN: setWearReporting($enabled)")
+        sgc?.setWearReporting(enabled)
+    }
+
+    fun setWearTuning(intervalMs: Int, count: Int, majority: Int) {
+        Bridge.log("MAN: setWearTuning($intervalMs, $count, $majority)")
+        sgc?.setWearTuning(intervalMs, count, majority)
+    }
+
+    fun requestWearTuning() {
+        Bridge.log("MAN: requestWearTuning()")
+        sgc?.requestWearTuning()
+    }
+
+    fun resetWearTuning() {
+        Bridge.log("MAN: resetWearTuning()")
+        sgc?.resetWearTuning()
+    }
+
     fun startStream(message: MutableMap<String, Any>) {
         Bridge.log("MAN: startStream")
         sgc?.startStream(message)
@@ -1976,6 +2001,11 @@ class DeviceManager {
         ar99.sendFactoryReset()
     }
 
+    fun sendGalleryServerEnabled(requestId: String, enabled: Boolean) {
+        val live = sgc as? MentraLive ?: throw IllegalStateException("unsupported_device")
+        live.sendGalleryServerEnabled(requestId, enabled)
+    }
+
     fun sendGalleryMode(requestId: String, enabled: Boolean) {
         val live = sgc as? MentraLive ?: throw IllegalStateException("unsupported_device")
         live.sendGalleryMode(requestId, enabled)

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

@@ -31,6 +31,16 @@ object DeviceStore {
                 JSONObject(mapOf("v" to newValue)).toString()
     }
 
+    /**
+     * Empty/`reset` mic tuning must still be written to the glasses. Native
+     * `update` drops null, and equal empty maps would otherwise skip BLE.
+     */
+    private fun isMicTuningReset(value: Any): Boolean {
+        val map = value as? Map<*, *> ?: return true
+        if (map.isEmpty()) return true
+        return map.entries.none { (key, field) -> key != "reset" && field is Number }
+    }
+
     private fun scheduleDashboardHeightToGlasses() {
         pendingDashboardHeightRunnable?.let { dashboardBleHandler.removeCallbacks(it) }
         val r = Runnable {
@@ -164,7 +174,10 @@ object DeviceStore {
     fun apply(category: String, key: String, value: Any) {
         val oldValue = store.get(category, key)
         store.set(category, key, value)
-        if (observableStoreWouldHaveSkipped(oldValue, value)) {
+        val skipped = observableStoreWouldHaveSkipped(oldValue, value)
+        val forceMicReset =
+                category == ObservableStore.BLUETOOTH_CATEGORY && key == "mic_tuning" && isMicTuningReset(value)
+        if (skipped && !forceMicReset) {
             return
         }
 
@@ -278,6 +291,12 @@ object DeviceStore {
             "bluetooth" to "loudness_gate_enabled" -> {
                 DeviceManager.getInstance().sgc?.sendLoudnessGateSetting()
             }
+            // Deliberately has no seeded default above: the key starts absent so
+            // that a session where the engine has not authorized tuning can only
+            // ever send a reset.
+            "bluetooth" to "mic_tuning" -> {
+                DeviceManager.getInstance().sgc?.sendMicTuningSetting()
+            }
             "bluetooth" to "nex_lc3_audio_playback" -> {
                 (value as? Boolean)?.let { enabled ->
                     Bridge.log("DeviceStore: nex_lc3_audio_playback changed to $enabled")

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

@@ -3,7 +3,8 @@ package com.mentra.bluetoothsdk
 /** Generated from /changelogs. Do not edit directly. */
 internal val GENERATED_RELEASE_CHANGELOGS: List<ReleaseChangelog> =
     listOf(
+        ReleaseChangelog(version = "3.2.1", markdown = "This release is under active development. User-facing changes will be documented as they land."),
         ReleaseChangelog(version = "3.2.0", markdown = "This release is under active development. User-facing changes will be documented as they land.\n\n- Breaking Bluetooth SDK change: `forgetWifiNetwork(ssid)` now returns `WifiForgetResult` instead of `WifiStatusChangeEvent`. Migrate status-only consumers to the semantic `outcome`; the requested network remains `ssid`, while optional post-command connectivity is reported by `connected`, `currentSsid`, and `localIp`."),
-        ReleaseChangelog(version = "3.1.1", markdown = "Software updates are more reliable, with clearer progress and recovery when the glasses restart.\n\n- MentraOS, Mentra Engine, the Bluetooth SDK, and the glasses client now share one coordinated release version.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic.\n- Bluetooth SDK usage analytics now report the host app's version, build type, and install source (store, TestFlight, sideload, simulator), plus the glasses firmware versions on identification, so store usage can be measured separately from development builds.\n- Bluetooth SDK usage analytics now identify G2 glasses by serial, keep long-lived connections visible across day boundaries, and retry failed uploads instead of dropping them."),
-        ReleaseChangelog(version = "3.1.0", markdown = "Software updates are more reliable, with clearer progress and recovery when the glasses restart.\n\n- MentraOS, Mentra Engine, the Bluetooth SDK, and the glasses client now share one coordinated release version.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic.\n- Bluetooth SDK usage analytics now report the host app's version, build type, and install source (store, TestFlight, sideload, simulator), plus the glasses firmware versions on identification, so store usage can be measured separately from development builds.\n- Bluetooth SDK usage analytics now identify G2 glasses by serial, keep long-lived connections visible across day boundaries, and retry failed uploads instead of dropping them."),
+        ReleaseChangelog(version = "3.1.1", markdown = "- Improved Google login on iOS.\n- Pairing no longer requires phone microphone access."),
+        ReleaseChangelog(version = "3.1.0", markdown = "**Mentra App and glasses**\n\n- Improved glasses pairing and reconnection, including on iPad.\n- Improved Android background reliability for captions and miniapps.\n- Added Xingyi AR99 support.\n- More reliable photo and video capture, with improved shutter sounds and privacy-light timing. Taking photos no longer interrupts your running miniapp.\n- Added video thumbnails and smoother gallery browsing.\n- Easier Mentra Live updates through your phone, with clearer progress and better recovery from interruptions.\n\n**Miniapp updates**\n\n- **Mentra AI:** Control whether photos are included with questions. Improved visual answers and connected-app follow-ups.\n- **Captions:** Added offline transcription settings and top/bottom positioning on supported displays.\n- **Translation:** Restored all 60 languages.\n- **Mentra Maps:** Clearer directions on G1/G2, less display flickering, and improved Android offline routing.\n- **Livestreamer:** More video-quality controls and custom streaming options, plus improved startup and sharing.\n- **Merge:** Tap to expand an insight; swipe down or back to dismiss it.\n- **Mentra Notes:** Smoother back navigation.\n- **Recorder:** Fixed audio sharing."),
     )

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

@@ -2,10 +2,10 @@ package com.mentra.bluetoothsdk
 
 /** Generated by release CI. Do not edit in a release checkout. */
 internal object GeneratedReleaseMetadata {
-    const val FAMILY_BASE_VERSION: String = "3.2.0"
-    const val RELEASE_IDENTITY: String = "3.2.0-dev.265"
-    const val RELEASE_SET_ID: String = "mentra-3.2.0-dev.265"
-    const val SOURCE_COMMIT: String = "e8e1ced74c05705b313769d49dfbf98f8bf5b1d2"
-    const val OTA_MANIFEST_URL: String = "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.265.json"
-    const val OTA_MANIFEST_SHA256: String = "c75ed12b14a9897db8c89a9bd3baa6bad432aa908e7fc0b0f50af8c7d8b8a9ad"
+    const val FAMILY_BASE_VERSION: String = "3.2.1"
+    const val RELEASE_IDENTITY: String = "3.2.1-beta.312"
+    const val RELEASE_SET_ID: String = "mentra-3.2.1-beta.312"
+    const val SOURCE_COMMIT: String = "0e549d30e1de230cc9f22e77b80ca1704833cceb"
+    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.312.json"
+    const val OTA_MANIFEST_SHA256: String = "c7d7975d15ab271035e7e26431be200d91664cc4c85b761e373ed4bc4026a3ac"
 }

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

@@ -601,6 +601,18 @@ class MentraBluetoothSdk private constructor(
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "screen_disabled", disabled)
     }
 
+    /**
+     * Enable or disable persistent, unauthenticated HTTP gallery access on the glasses' Wi-Fi.
+     * Defaults off and survives glasses restarts. Only enable on a trusted network.
+     * The ack reports saved enabled state and current listening/url separately.
+     */
+    suspend fun setGalleryServerEnabled(enabled: Boolean): SettingsAckEvent =
+        performSettingsCommand(
+            setting = "gallery_server",
+            updateStore = {},
+            send = { requestId -> deviceManager.sendGalleryServerEnabled(requestId, enabled) },
+        )
+
     suspend fun setGalleryModeEnabled(enabled: Boolean): SettingsAckEvent =
         performSettingsCommand(
             setting = "gallery_mode",

package/android/src/main/java/com/mentra/bluetoothsdk/events/BluetoothEvents.kt

@@ -125,6 +125,13 @@ data class SettingsAckEvent(
     val hardwareApplied: Boolean get() = boolValue(values, "hardwareApplied", "hardware_applied") ?: false
     val errorCode: String? get() = stringValue(values, "errorCode")
     val errorMessage: String? get() = stringValue(values, "errorMessage")
+    /** Saved setting value, when included in the acknowledgement. */
+    val enabled: Boolean? get() = values["enabled"] as? Boolean
+    /** Whether the persistent gallery server is currently available over station Wi-Fi. */
+    val listening: Boolean? get() = values["listening"] as? Boolean
+    /** Current gallery base URL, available only with a running server and station Wi-Fi. */
+    val url: String? get() = stringValue(values, "url")
+
 }
 
 data class RgbLedControlResponseEvent(

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

@@ -703,9 +703,8 @@ class Mach1 : SGCManager() {
     }
 
     fun blankScreen() {
-//        if (connectedGlasses != null){
-//            connectedGlasses.clear();
-//        }
+        ultraliteSdk?.screenOff()
+        screenIsClear = true
     }
 
     fun destroy() {
@@ -781,13 +780,13 @@ class Mach1 : SGCManager() {
     }
 
     fun changeUltraliteLayout(chosenLayout: Layout) {
+        ultraliteSdk!!.screenOn()
+
         //don't update layout if it's already setup
         if (currentUltraliteLayout != null && currentUltraliteLayout == chosenLayout) {
             return
         }
 
-        ultraliteSdk!!.screenOn()
-
         currentUltraliteLayout = chosenLayout
         ultraliteSdk!!.setLayout(chosenLayout, 0, true, false, 2)