@mentra/bluetooth-sdk 0.1.21-beta.0 → 0.1.21-beta.2

package/README.md

@@ -152,11 +152,13 @@ reordering rows just because RSSI metadata arrives later.
 
 ## Mentra SDK Usage Analytics
 
-The SDK sends two anonymous usage events to Mentra's PostHog project by default
-so Mentra can understand SDK adoption and successful glasses connections:
+The SDK sends three usage events to Mentra's PostHog project by default so
+Mentra can understand SDK adoption, successful glasses connections, and
+enterprise device deployments:
 
 - `bluetooth_sdk_started`: sent once per app runtime after the native SDK starts.
 - `bluetooth_sdk_glasses_connected`: sent when SDK status transitions from not connected to connected.
+- `bluetooth_sdk_glasses_identified`: sent once per connection after the SDK receives a valid manufacturing serial from the glasses. This fires for every supported model that reports a serial. G1 and Ar99 decode the serial from the glasses' BLE advertisement, so they emit this event as soon as this SDK version ships. Mentra Live instead reports the serial provisioned in BES NV storage, which requires compatible BES firmware and `asg_client` software.
 
 Analytics delivery is fire-and-forget: events are submitted asynchronously, do
 not block Bluetooth SDK behavior, and are not retried if delivery fails.
@@ -190,14 +192,23 @@ write token, not a private PostHog personal API key. Apps do not configure the
 analytics destination; these SDK usage events are always sent to Mentra's
 PostHog project unless analytics are disabled.
 
-Captured properties are limited to non-sensitive SDK/app metadata:
-`event_source`, `sdk_platform`, `sdk_surface`, `sdk_version`, the app package or
-bundle identifier, OS platform/version, `event_kind`, and for connection events
-only `fully_booted` plus a glasses model value when the SDK knows it. The SDK
-does not upload BLE MAC addresses, CoreBluetooth identifiers, serial numbers,
-Bluetooth device names, user ids, tokens, Wi-Fi credentials, microphone data,
-photos, or transcripts. PostHog receives a locally generated anonymous SDK
-install id as `distinct_id`, and events include `$process_person_profile: false`.
+Captured properties include `event_source`, `sdk_platform`, `sdk_surface`,
+`sdk_version`, `app_identifier` (the Android package or iOS bundle identifier),
+the platform-specific `app_package` or `app_bundle_identifier`, OS
+platform/version, and `event_kind`. Connection events also include
+`fully_booted` and a glasses model value when known. The identification event
+intentionally includes the glasses manufacturing serial as `glasses_device_id`,
+with `glasses_device_id_type=manufacturing_serial`, so Mentra can correlate
+fleet deployments across supported models. This serial identifies the glasses
+hardware, not the user or the host phone. Its source depends on the model:
+Mentra Live reports the serial provisioned in BES NV storage, while G1 and Ar99
+decode it from the glasses' BLE advertisement / manufacturer data.
+
+Apart from that glasses serial, the SDK does not upload BLE MAC addresses,
+CoreBluetooth identifiers, the host phone's Android device serial, Bluetooth
+device names, user ids, tokens, Wi-Fi credentials, microphone data, photos, or
+transcripts. PostHog receives a locally generated anonymous SDK install id as
+`distinct_id`, and events include `$process_person_profile: false`.
 
 ## React Hooks
 
@@ -408,7 +419,7 @@ 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. 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`.
+`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`. While live, supported firmware emits periodic `streaming` events whose `stats` object contains `bitrate` (bits per second), `fps`, `droppedFrames`, `duration` (seconds), and `temperatureC` when the CPU sensor is available.
 
 ## Events
 

package/android/build.gradle

@@ -279,6 +279,9 @@ dependencies {
   // Local photo upload receiver
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.1"
 
+  // AR99 GATT Opus to PCM decoder.
+  implementation 'io.github.jaredmdobson:concentus:1.0.1'
+
   // LC3 audio codec library
   implementation project(':lc3Lib')
 

package/android/src/main/AndroidManifest.xml

@@ -28,6 +28,8 @@
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE"/>
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC"/>
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION"/>
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK"/>
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE"/>
 
   <!-- Other permissions -->
@@ -35,6 +37,6 @@
   <uses-permission android:name="android.permission.VIBRATE"/>
 
   <application>
-    <service android:name="com.mentra.bluetoothsdk.services.ForegroundService" android:exported="false" android:foregroundServiceType="dataSync|connectedDevice|microphone"/>
+    <service android:name="com.mentra.bluetoothsdk.services.ForegroundService" android:exported="false" android:foregroundServiceType="dataSync|connectedDevice|location|mediaPlayback|microphone"/>
   </application>
 </manifest>

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

@@ -48,10 +48,17 @@ internal class BluetoothSdkAnalytics(
     private val config = initialConfig.toRuntimeConfig().resolvedForApp(appContext)
     private var startedCaptured = false
     private var lastConnected = false
+    private var identifiedCapturedForConnection = false
 
     @Synchronized
     fun initializeGlassesStatus(status: GlassesStatus) {
         lastConnected = status.analyticsConnected
+        // Only treat identification as already captured when a valid serial is
+        // present at init. If the glasses are connected but the serial has not
+        // arrived yet (Mentra Live fills it via version_info after connect), leave
+        // this false so the identify event still fires once the serial arrives.
+        identifiedCapturedForConnection =
+            status.analyticsConnected && status.serialNumber.validManufacturingSerial() != null
     }
 
     @Synchronized
@@ -67,7 +74,12 @@ internal class BluetoothSdkAnalytics(
         val wasConnected = lastConnected
         lastConnected = isConnected
         if (!config.isReady) return
+        if (!isConnected) {
+            identifiedCapturedForConnection = false
+            return
+        }
         if (isConnected && !wasConnected) {
+            identifiedCapturedForConnection = false
             capture(
                 "bluetooth_sdk_glasses_connected",
                 buildMap {
@@ -76,6 +88,24 @@ internal class BluetoothSdkAnalytics(
                     status.deviceModel.takeIf { it.isNotBlank() }?.let { put("glasses_model", it) }
                 },
             )
+            // Fall through: a serial already present at connect time (G1/Ar99 report
+            // it in the advertisement) should be identified now rather than waiting
+            // for some later, unrelated glasses-store update to run.
+        }
+
+        val serialNumber = status.serialNumber.validManufacturingSerial() ?: return
+        if (!identifiedCapturedForConnection) {
+            identifiedCapturedForConnection = true
+            capture(
+                "bluetooth_sdk_glasses_identified",
+                buildMap {
+                    put("event_kind", "glasses_identified")
+                    put("fully_booted", status.fullyBooted)
+                    put("glasses_device_id", serialNumber)
+                    put("glasses_device_id_type", "manufacturing_serial")
+                    status.deviceModel.takeIf { it.isNotBlank() }?.let { put("glasses_model", it) }
+                },
+            )
         }
     }
 
@@ -131,6 +161,7 @@ internal class BluetoothSdkAnalytics(
             put("sdk_platform", "android")
             put("sdk_surface", activeConfig.surface)
             put("sdk_version", BuildConfig.SDK_VERSION)
+            put("app_identifier", appContext.packageName)
             put("app_package", appContext.packageName)
             put("os_platform", "android")
             put("os_version", Build.VERSION.SDK_INT)
@@ -180,3 +211,6 @@ private fun BluetoothSdkAnalyticsRuntimeConfig.resolvedForApp(context: Context):
 
 private val GlassesStatus.analyticsConnected: Boolean
     get() = connectionState.isConnected || connected || fullyBooted
+
+private fun String.validManufacturingSerial(): String? =
+    trim().takeIf { it.isNotEmpty() && !it.matches(Regex("0+")) }

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

@@ -3,4 +3,5 @@ package com.mentra.bluetoothsdk
 /** Defaults for the public Bluetooth SDK surface. */
 object BluetoothSdkDefaults {
     const val VOICE_ACTIVITY_DETECTION_ENABLED = false
+    const val LOUDNESS_GATE_ENABLED = true
 }

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

@@ -2,6 +2,8 @@
 
 package com.mentra.bluetoothsdk
 
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
 import com.mentra.bluetoothsdk.debug.BleTraceLogger
 import com.mentra.bluetoothsdk.utils.DeviceTypes
 import com.mentra.bluetoothsdk.utils.audio.PcmStreamManager
@@ -12,6 +14,7 @@ import expo.modules.kotlin.modules.ModuleDefinition
 import expo.modules.kotlin.modules.ModuleDefinitionBuilder
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import java.security.MessageDigest
 
 // Expo has no module-level error mapper, so SDK-backed registrations translate
 // core exceptions here while keeping Expo types out of the native SDK API.
@@ -365,10 +368,12 @@ class BluetoothSdkModule : Module() {
             "stream_status",
             "keep_alive_ack",
             "mtk_update_complete",
+            "glasses_session_changed",
             "ota_progress",
             "ota_start_ack",
             "ota_status",
-            // Nex / BLE debug (NexEventUtils → Bridge.sendTypedMessage)
+            "ar99_ota_status",
+            // Nex / BLE debug (NexEventUtils —Bridge.sendTypedMessage)
             "send_command_to_ble",
             "receive_command_from_ble",
             "miniapp_selected",
@@ -391,6 +396,21 @@ class BluetoothSdkModule : Module() {
                             sdkListener,
                     )
             deviceManager = DeviceManager.getInstance()
+            val activity = appContext.currentActivity
+            val activityIsResumed =
+                    (activity as? LifecycleOwner)
+                            ?.lifecycle
+                            ?.currentState
+                            ?.isAtLeast(Lifecycle.State.RESUMED) == true
+            if (activityIsResumed) {
+                deviceManager?.refreshForegroundServiceTypes()
+            }
+        }
+
+        OnActivityEntersForeground {
+            // Re-run after runtime permission dialogs and every app resume. This is the safe
+            // point to add Android's while-in-use location foreground-service type.
+            deviceManager?.refreshForegroundServiceTypes()
         }
 
         OnDestroy {
@@ -565,6 +585,10 @@ class BluetoothSdkModule : Module() {
             sdk?.setVoiceActivityDetectionEnabled(enabled)
         }
 
+        SdkAsyncFunction("setLoudnessGateEnabled") { enabled: Boolean ->
+            sdk?.setLoudnessGateEnabled(enabled)
+        }
+
         @Suppress("DEPRECATION")
         SdkCoroutineFunction("setPhotoCaptureDefaults") { params: Map<String, Any?> ->
             requireSdk().setPhotoCaptureDefaults(params.toPhotoCaptureDefaults()).values
@@ -643,7 +667,9 @@ class BluetoothSdkModule : Module() {
                 if (exposureRaw != null && exposureRaw.isFinite() && exposureRaw > 0) exposureRaw.toLong() else null
             val durationRaw = (params["durationMs"] as? Number)?.toInt() ?: 0
             val durationMs = if (durationRaw > 0) durationRaw else 15000
-            requireSdk().warmUpCamera(requestId, size, mode, exposureTimeNs, durationMs).values
+            val zsl = params["zsl"] as? Boolean
+            val mfnr = params["mfnr"] as? Boolean
+            requireSdk().warmUpCamera(requestId, size, mode, exposureTimeNs, durationMs, zsl, mfnr).values
         }
 
         SdkAsyncFunction("stopCameraWarmUp") { requestId: String ->
@@ -675,6 +701,18 @@ class BluetoothSdkModule : Module() {
 
         SdkCoroutineFunction("sendOtaQueryStatus") { -> requireSdk().sendOtaQueryStatus().values }
 
+        AsyncFunction("startAr99OtaFromFile") { path: String -> requireSdk().startAr99OtaFromFile(path) }
+
+        AsyncFunction("cancelAr99Ota") { requireSdk().cancelAr99Ota() }
+
+        AsyncFunction("sendAr99FactoryReset") { requireSdk().sendAr99FactoryReset() }
+
+
+        Function("buildAr99OtaSignature") { secret: String, appName: String, currentVersion: String, serialNumber: String, nonce: String ->
+            val raw = secret + appName + "juxinOTA" + currentVersion + serialNumber.trim() + nonce
+            val digest = MessageDigest.getInstance("MD5").digest(raw.toByteArray(Charsets.UTF_8))
+            digest.joinToString("") { "%02x".format(it.toInt() and 0xff) }
+        }
         // MARK: - Version Info Commands
 
         SdkCoroutineFunction("requestVersionInfo") { -> requireSdk().requestVersionInfo().toMap() }
@@ -858,7 +896,7 @@ class BluetoothSdkModule : Module() {
         }
 
         // Runs on Dispatchers.IO, not the shared Expo AsyncFunctionQueue: bz2/tar
-        // extraction of the 100–350MB model is a multi-minute, CPU-bound job. On the
+        // extraction of the 100—50MB model is a multi-minute, CPU-bound job. On the
         // shared queue it froze every other native call in the app until it finished.
         AsyncFunction("extractTarBz2") Coroutine { sourcePath: String, destinationPath: String ->
             withContext(Dispatchers.IO) {
@@ -935,12 +973,14 @@ private fun Map<String, Any>?.toMentraDevice(): Device? {
     val model = values["model"] as? String ?: return null
     val name = values["name"] as? String ?: return null
     val address = values["address"] as? String
+    val projectName = values["projectName"] as? String
     val rssi = (values["rssi"] as? Number)?.toInt()
     val id = values["id"] as? String
     return Device(
             model = DeviceModel.fromDeviceType(model),
             name = name,
             address = address?.takeIf { it.isNotBlank() },
+            projectName = projectName?.takeIf { it.isNotBlank() },
             rssi = rssi,
             id = id?.takeIf { it.isNotBlank() } ?: address?.takeIf { it.isNotBlank() } ?: "$model:$name",
     )

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

@@ -250,7 +250,8 @@ public class Bridge private constructor() {
                 deviceModel: String,
                 deviceName: String,
                 deviceAddress: String = "",
-                rssi: Int? = null
+                rssi: Int? = null,
+                projectName: String? = null
         ) {
             val searchResults =
                     (DeviceStore.store.getCategory("bluetooth")["searchResults"] as? List<*>)
@@ -262,7 +263,7 @@ public class Bridge private constructor() {
                                         ?.toMap()
                             }
                             ?: emptyList()
-            val id = "$deviceModel:$deviceName"
+            val id = listOfNotNull(deviceModel, projectName?.takeIf { it.isNotBlank() }, deviceName).joinToString(":")
             val newResult =
                     buildMap<String, Any> {
                         put("id", id)
@@ -271,6 +272,7 @@ public class Bridge private constructor() {
                         if (deviceAddress.isNotBlank()) {
                             put("address", deviceAddress)
                         }
+                        projectName?.takeIf { it.isNotBlank() }?.let { put("projectName", it) }
                         rssi?.let { put("rssi", it) }
                     }
             // Keep the public searchResults array stable as glasses are added or removed.
@@ -872,3 +874,6 @@ public class Bridge private constructor() {
         }
     }
 }
+
+
+

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

@@ -14,6 +14,7 @@ import com.mentra.bluetoothsdk.controllers.ControllerManager
 import com.mentra.bluetoothsdk.controllers.R1
 import com.mentra.bluetoothsdk.services.ForegroundService
 import com.mentra.bluetoothsdk.services.PhoneMic
+import com.mentra.bluetoothsdk.sgcs.Ar99
 import com.mentra.bluetoothsdk.sgcs.G1
 import com.mentra.bluetoothsdk.sgcs.G2
 import com.mentra.bluetoothsdk.sgcs.SceneElement
@@ -28,6 +29,7 @@ import com.mentra.bluetoothsdk.utils.ControllerTypes
 import com.mentra.bluetoothsdk.utils.DeviceTypes
 import com.mentra.bluetoothsdk.utils.MicMap
 import com.mentra.bluetoothsdk.utils.MicTypes
+import com.mentra.bluetoothsdk.utils.PhoneAudioMonitor
 import com.mentra.lc3Lib.Lc3Cpp
 import com.mentra.bluetoothsdk.stt.SherpaOnnxTranscriber
 import kotlinx.coroutines.CoroutineScope
@@ -334,6 +336,11 @@ class DeviceManager {
             return
         }
 
+        if (PhoneAudioMonitor.getInstance(Bridge.getContext()).isOwnAppAudioPlaying()) {
+            Bridge.log("MAN: Mentra audio is playing; skipping glasses mic recovery")
+            return
+        }
+
         // When no frame has ever been received, treat elapsed as "forever" so we
         // actually attempt recovery (was 0 before, which made the watchdog a no-op).
         val timeSinceLastLc3Event = System.currentTimeMillis() - (lastLc3Event ?: 0L)
@@ -576,6 +583,36 @@ class DeviceManager {
         }
     }
 
+    /**
+     * Re-evaluate the active foreground-service types while the host Activity is visible.
+     *
+     * Location is a while-in-use permission, so Android 14+ only allows the service to add
+     * the location type from the foreground. Sending a command to the existing service
+     * updates its type mask without tearing down the glasses connection.
+     */
+    fun refreshForegroundServiceTypes() {
+        val context = Bridge.getContext()
+
+        try {
+            Bridge.log("MAN: Refreshing foreground service types")
+            val serviceIntent =
+                Intent(context, ForegroundService::class.java).apply {
+                    action = ForegroundService.ACTION_REFRESH_TYPES
+                }
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                context.startForegroundService(serviceIntent)
+            } else {
+                context.startService(serviceIntent)
+            }
+
+            serviceStarted = true
+            Bridge.log("MAN: Foreground service types refreshed")
+        } catch (e: Exception) {
+            Bridge.log("MAN: Failed to refresh foreground service types: ${e.message}")
+        }
+    }
+
     private fun restartForegroundService() {
         val context = Bridge.getContext()
 
@@ -1122,6 +1159,8 @@ class DeviceManager {
             sgc = MentraLive()
         } else if (wearable.contains(DeviceTypes.NEX)) {
             sgc = MentraNex()
+        } else if (wearable.contains(DeviceTypes.AR99)) {
+            sgc = Ar99()
         } else if (wearable.contains(DeviceTypes.MACH1)) {
             sgc = createOptionalMach1Sgc(DeviceTypes.MACH1)
         } else if (wearable.contains(DeviceTypes.Z100)) {
@@ -1199,6 +1238,10 @@ class DeviceManager {
                 }
             )
             nextTranscriber.initialize()
+            if (!nextTranscriber.isInitialized()) {
+                Bridge.log("SherpaOnnxTranscriber initialize() returned without becoming ready")
+                return false
+            }
             transcriber = nextTranscriber
             Bridge.log("SherpaOnnxTranscriber fully initialized")
             true
@@ -1285,6 +1328,10 @@ class DeviceManager {
         Bridge.saveSetting("default_wearable", defaultWearable)
         Bridge.saveSetting("device_name", deviceName)
         Bridge.saveSetting("device_address", deviceAddress)
+        if (defaultWearable.contains(DeviceTypes.AR99)) {
+            val projectName = (DeviceStore.store.get("bluetooth", "project_name") as? String)?.trim().orEmpty()
+            Bridge.saveSetting("project_name", projectName)
+        }
     }
 
     private fun syncSystemTimeOnceForConnection(connectionKey: String) {
@@ -1611,6 +1658,20 @@ class DeviceManager {
         (sgc as? MentraLive)?.sendOtaQueryStatus()
     }
 
+    fun startAr99OtaFromFile(path: String): Boolean {
+        val ar99 = sgc as? Ar99 ?: throw IllegalStateException("unsupported_device")
+        return ar99.startOtaFromFile(path)
+    }
+
+    fun cancelAr99Ota() {
+        (sgc as? Ar99)?.cancelAr99Ota()
+    }
+
+    fun sendAr99FactoryReset() {
+        val ar99 = sgc as? Ar99 ?: throw IllegalStateException("unsupported_device")
+        ar99.sendFactoryReset()
+    }
+
     fun sendGalleryMode(requestId: String, enabled: Boolean) {
         val live = sgc as? MentraLive ?: throw IllegalStateException("unsupported_device")
         live.sendGalleryMode(requestId, enabled)
@@ -1697,6 +1758,8 @@ class DeviceManager {
         mode: PhotoMode = PhotoMode.PHOTO,
         exposureTimeNs: Long?,
         durationMs: Int,
+        zsl: Boolean? = null,
+        mfnr: Boolean? = null,
     ) {
         // Fail fast like other camera commands so the SDK promise rejects immediately instead of
         // hanging until the request timeout with no camera_status.
@@ -1706,7 +1769,7 @@ class DeviceManager {
                     "unsupported_device",
                     "This command requires Mentra Live glasses.",
                 )
-        live.warmUpCamera(requestId, size, mode, exposureTimeNs, durationMs)
+        live.warmUpCamera(requestId, size, mode, exposureTimeNs, durationMs, zsl, mfnr)
     }
 
     fun stopCameraWarmUp(requestId: String) {
@@ -1715,7 +1778,7 @@ class DeviceManager {
     }
 
     /**
-     * Read glasses media step volume (0–15) via K900 on Mentra Live only. Blocks until response,
+     * Read glasses media step volume (0—5) via K900 on Mentra Live only. Blocks until response,
      * error, or timeout (used from JS AsyncFunction on a worker thread).
      */
     fun getGlassesMediaVolumeBlocking(): Map<String, Any> {
@@ -1741,7 +1804,7 @@ class DeviceManager {
         return result ?: throw IllegalStateException("glasses_volume_empty")
     }
 
-    /** Set glasses media step volume (0–15) via K900 on Mentra Live only. */
+    /** Set glasses media step volume (0—5) via K900 on Mentra Live only. */
     fun setGlassesMediaVolumeBlocking(level: Int): Map<String, Any> {
         val live = sgc as? MentraLive ?: throw IllegalStateException("unsupported_device")
         val latch = CountDownLatch(1)
@@ -1873,8 +1936,14 @@ class DeviceManager {
             Bridge.log("MAN: No default wearable, returning")
             return
         }
-        if (deviceName.isEmpty()) {
-            Bridge.log("MAN: No device name, returning")
+        val reconnectTarget =
+            if (defaultWearable.contains(DeviceTypes.AR99) && deviceAddress.isNotBlank()) {
+                deviceAddress
+            } else {
+                deviceName
+            }
+        if (reconnectTarget.isEmpty()) {
+            Bridge.log("MAN: No reconnect target, returning")
             return
         }
         if (!hasBluetoothPermissions()) {
@@ -1886,7 +1955,7 @@ class DeviceManager {
         }
         initSGC(defaultWearable)
         searching = true
-        sgc?.connectById(deviceName)
+        sgc?.connectById(reconnectTarget)
         connectDefaultController()
     }
 
@@ -1981,6 +2050,11 @@ class DeviceManager {
         shouldSendBootingMessage = true // Reset for next first connect
         // clear glasses properties:
         DeviceStore.apply("glasses", "deviceModel", "")
+        // A manufacturing serial is session-bound. Clear it on every disconnect so a
+        // previously connected pair's serial can never be reported for the next
+        // connection (e.g. switching from G1/Ar99, which populate it from the
+        // advertisement, to a model that never writes it, like G2).
+        DeviceStore.apply("glasses", "serialNumber", "")
         DeviceStore.apply("glasses", "fullyBooted", false)
         DeviceStore.apply("glasses", "connected", false)
         DeviceStore.apply(
@@ -2019,6 +2093,7 @@ class DeviceManager {
         Bridge.saveSetting("default_wearable", "")
         Bridge.saveSetting("device_name", "")
         Bridge.saveSetting("device_address", "")
+        Bridge.saveSetting("project_name", "")
     }
 
     fun forgetController() {
@@ -2089,3 +2164,4 @@ class DeviceManager {
         }
     }
 }
+

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

@@ -125,10 +125,11 @@ object DeviceStore {
         store.set("bluetooth", "contextual_dashboard", true)
         store.set("bluetooth", "gallery_mode", true)
         store.set("bluetooth", "voice_activity_detection_enabled", BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED)
+        store.set("bluetooth", "loudness_gate_enabled", BluetoothSdkDefaults.LOUDNESS_GATE_ENABLED)
         store.set("bluetooth", "screen_disabled", false)
         store.set("bluetooth", "button_photo_size", "max")
         store.set("bluetooth", "button_max_recording_time", 10)
-        store.set("bluetooth", "camera_fov", mapOf("fov" to 102, "roi_position" to 0))
+        store.set("bluetooth", "camera_fov", mapOf("fov" to 118, "roi_position" to 0))
         store.set("bluetooth", "button_video_width", 1280)
         store.set("bluetooth", "button_video_height", 720)
         store.set("bluetooth", "button_video_fps", 30)
@@ -268,6 +269,9 @@ object DeviceStore {
             "bluetooth" to "voice_activity_detection_enabled" -> {
                 DeviceManager.getInstance().sgc?.sendVoiceActivityDetectionSetting()
             }
+            "bluetooth" to "loudness_gate_enabled" -> {
+                DeviceManager.getInstance().sgc?.sendLoudnessGateSetting()
+            }
             "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/MentraBluetoothSdk.kt

@@ -68,7 +68,7 @@ class MentraBluetoothSdk private constructor(
     }
 
     companion object {
-        private val DEFAULT_DEVICE_KEYS = setOf("default_wearable", "device_name", "device_address")
+        private val DEFAULT_DEVICE_KEYS = setOf("default_wearable", "device_name", "device_address", "project_name")
         private val SCAN_STATE_KEYS = setOf("searching", "searchingController", "searchResults")
         private const val DEFAULT_SCAN_TIMEOUT_MS = 15_000L
         private const val DEFAULT_REQUEST_TIMEOUT_MS = 15_000L
@@ -257,6 +257,7 @@ class MentraBluetoothSdk private constructor(
             DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "default_wearable", device.model.deviceType)
             DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "device_name", device.name)
             DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "device_address", device.address ?: "")
+            DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "project_name", device.projectName ?: "")
         } finally {
             suppressDefaultDeviceEvents = false
         }
@@ -269,6 +270,7 @@ class MentraBluetoothSdk private constructor(
             DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "default_wearable", "")
             DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "device_name", "")
             DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "device_address", "")
+            DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "project_name", "")
         } finally {
             suppressDefaultDeviceEvents = false
         }
@@ -513,10 +515,14 @@ class MentraBluetoothSdk private constructor(
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "voice_activity_detection_enabled", enabled)
     }
 
+    fun setLoudnessGateEnabled(enabled: Boolean) {
+        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "loudness_gate_enabled", enabled)
+    }
+
     @Deprecated(
         message =
             "Sticky action-button photo presets are deprecated. Prefer per-request " +
-                "requestPhoto(...) options (e.g. mode=TEXT for AE ÷3, or explicit per-shot fields). " +
+                "requestPhoto(...) options (e.g. mode=TEXT for text sensor size/crop, or explicit per-shot fields). " +
                 "This method still works but will be removed in a future release.",
     )
     suspend fun setPhotoCaptureDefaults(settings: PhotoCaptureDefaults): SettingsAckEvent =
@@ -526,6 +532,7 @@ class MentraBluetoothSdk private constructor(
                 if (settings.resetCaptureTuning) {
                     // Clear all stored scan-tuning keys from phone cache
                     listOf(
+                        "button_photo_zsl_mfnr",
                         "button_photo_mfnr",
                         "button_photo_zsl",
                         "button_photo_noise_reduction",
@@ -877,6 +884,8 @@ class MentraBluetoothSdk private constructor(
         mode: PhotoMode = PhotoMode.PHOTO,
         exposureTimeNs: Long?,
         durationMs: Int,
+        zsl: Boolean? = null,
+        mfnr: Boolean? = null,
     ): CameraStatusEvent {
         val effectiveRequestId = nonBlankRequestId(requestId) ?: generatedCameraRequestId("warm")
         val pending = PendingResponse<CameraStatusEvent>("camera warm up $effectiveRequestId")
@@ -889,7 +898,7 @@ class MentraBluetoothSdk private constructor(
             )
         }
         try {
-            deviceManager.warmUpCamera(effectiveRequestId, size, mode, exposureTimeNs, durationMs)
+            deviceManager.warmUpCamera(effectiveRequestId, size, mode, exposureTimeNs, durationMs, zsl, mfnr)
             return pending.await()
         } finally {
             pendingCameraStatusRequests.remove(effectiveRequestId, pending)
@@ -1200,6 +1209,20 @@ class MentraBluetoothSdk private constructor(
 
     internal suspend fun sendOtaQueryStatus(): OtaQueryResult = queryOtaStatus()
 
+    fun startAr99OtaFromFile(path: String): Boolean {
+        requireGlassesConnected("start AR99 OTA")
+        return deviceManager.startAr99OtaFromFile(path)
+    }
+
+    fun cancelAr99Ota() {
+        deviceManager.cancelAr99Ota()
+    }
+
+    fun sendAr99FactoryReset() {
+        requireGlassesConnected("factory reset AR99")
+        deviceManager.sendAr99FactoryReset()
+    }
+
     private suspend fun getFreshGlassesStatus(): GlassesStatus {
         val status = getRawGlassesStatus()
         if (!status.connected || status.buildNumber.isNotBlank()) {
@@ -1345,10 +1368,12 @@ class MentraBluetoothSdk private constructor(
         val name = core["device_name"] as? String ?: return null
         if (model.isBlank() || name.isBlank()) return null
         val address = (core["device_address"] as? String)?.takeIf { it.isNotBlank() }
+        val projectName = (core["project_name"] as? String)?.takeIf { it.isNotBlank() }
         return Device(
             model = DeviceModel.fromDeviceType(model),
             name = name,
             address = address,
+            projectName = projectName,
         )
     }
 
@@ -2135,3 +2160,7 @@ class MentraBluetoothSdk private constructor(
         }
     }
 }
+
+
+
+