@mentra/bluetooth-sdk 0.1.20 → 0.1.21-beta.1

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.
@@ -520,30 +522,81 @@ public class Bridge private constructor() {
             sendTypedMessage("glasses_serial_number", body as Map<String, Any>)
         }
 
-        /** Send WiFi status change */
+        /**
+         * Send WiFi status change. [error] is the glasses' provisioning failure reason
+         * (e.g. "connect_timeout", "connected_to_other_network") when this status is the
+         * verdict of a failed connect attempt; null for routine link-state updates.
+         */
         @JvmStatic
-        fun sendWifiStatusChange(connected: Boolean, ssid: String?, localIp: String?) {
+        @JvmOverloads
+        fun sendWifiStatusChange(
+                connected: Boolean,
+                ssid: String?,
+                localIp: String?,
+                error: String? = null
+        ) {
             val status = WifiStatus.fromStoreFields(connected, ssid, localIp) ?: return
-            sendTypedMessage("wifi_status_change", status.toMap())
+            val payload =
+                    if (error != null) status.toMap() + mapOf("error" to error)
+                    else status.toMap()
+            sendTypedMessage("wifi_status_change", payload)
+        }
+
+        /**
+         * Claim the WiFi scan-results store for a newly requested scan. Called by the
+         * SDK when it generates the scanId, BEFORE the scan command goes out: store
+         * ownership is decided at request time, not by whichever chunk arrives first,
+         * so a delayed chunk from an older, abandoned scan can never reset or clobber
+         * the current scan's accumulator.
+         */
+        @JvmStatic
+        fun claimWifiScanResults(scanId: String) {
+            DeviceStore.apply("bluetooth", "wifiScanActiveScanId", scanId)
         }
 
         /** Send WiFi scan results */
         @JvmStatic
-        fun updateWifiScanResults(networks: List<Map<String, Any>>, scanComplete: Boolean) {
-            var storedNetworks: List<Map<String, Any>> =
-                    DeviceStore.get("bluetooth", "wifiScanResults") as? List<Map<String, Any>>
-                            ?: emptyList()
-            // add the networks to the storedNetworks array, removing duplicates by ssid
-            val updatedNetworks = storedNetworks.toMutableList()
-            for (network in networks) {
-                if (!updatedNetworks.any { it["ssid"] as? String == network["ssid"] as? String }) {
-                    updatedNetworks.add(network)
+        fun updateWifiScanResults(
+                networks: List<Map<String, Any>>,
+                scanComplete: Boolean,
+                scanId: String? = null
+        ) {
+            // Only chunks echoing the active scanId claimed at request time may mutate
+            // the store; foreign chunks are still forwarded to the SDK sink, which
+            // drops stale ids itself. Scan-id-less chunks (old firmware) keep the
+            // legacy accumulate-forever store behavior.
+            val ownsStore =
+                    scanId == null || scanId == DeviceStore.get("bluetooth", "wifiScanActiveScanId")
+            var updatedNetworks: List<Map<String, Any>> = networks
+            if (ownsStore) {
+                var storedNetworks: List<Map<String, Any>> =
+                        DeviceStore.get("bluetooth", "wifiScanResults") as? List<Map<String, Any>>
+                                ?: emptyList()
+                val lastScanId = DeviceStore.get("bluetooth", "wifiScanResultsScanId")
+                if (scanId != null && scanId != lastScanId) {
+                    // First chunk of a new scan: drop networks accumulated for a previous scan
+                    // so stale entries never carry over into this scan's store.
+                    storedNetworks = emptyList()
+                    DeviceStore.apply("bluetooth", "wifiScanResultsScanId", scanId)
+                }
+                // add the networks to the storedNetworks array, removing duplicates by ssid
+                val merged = storedNetworks.toMutableList()
+                for (network in networks) {
+                    if (!merged.any { it["ssid"] as? String == network["ssid"] as? String }) {
+                        merged.add(network)
+                    }
                 }
+                DeviceStore.apply("bluetooth", "wifiScanResults", merged)
+                updatedNetworks = merged
             }
-            DeviceStore.apply("bluetooth", "wifiScanResults", updatedNetworks)
             val body = HashMap<String, Any>()
-            body["networks"] = updatedNetworks
+            // Correlated scans: the SDK accumulates and dedupes chunks per scanId itself,
+            // so forward only this chunk; the merged store list is for UI consumers.
+            body["networks"] = if (scanId != null) networks else updatedNetworks
             body["scanComplete"] = scanComplete
+            if (scanId != null) {
+                body["scanId"] = scanId
+            }
             sendTypedMessage("wifi_scan_result", body)
         }
 
@@ -821,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
@@ -329,6 +331,16 @@ class DeviceManager {
             return
         }
 
+        if (sgc?.isMicSuspendedForAudio == true) {
+            Bridge.log("MAN: Glasses mic intentionally suspended for phone audio; skipping mic recovery")
+            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)
@@ -571,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()
 
@@ -1117,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)) {
@@ -1194,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
@@ -1280,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) {
@@ -1556,10 +1608,10 @@ class DeviceManager {
         sgc?.sendStreamKeepAlive(message)
     }
 
-    fun requestWifiScan() {
+    fun requestWifiScan(scanId: String? = null) {
         Bridge.log("MAN: Requesting wifi scan")
         DeviceStore.apply("bluetooth", "wifiScanResults", emptyList<Any>())
-        sgc?.requestWifiScan()
+        sgc?.requestWifiScan(scanId)
     }
 
     fun sendIncidentId(incidentId: String, apiBaseUrl: String? = null) {
@@ -1606,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)
@@ -1649,6 +1715,38 @@ class DeviceManager {
         live.sendCameraFovSetting(requestId, fov, roiPosition)
     }
 
+    /** Sends the pre-lease FOV command used by ASG clients that do not send an acknowledgement. */
+    fun sendLegacyCameraFovSetting(fov: Int, roiPosition: Int) {
+        val glassesConnected = DeviceStore.get("glasses", "connected") as? Boolean ?: false
+        if (!glassesConnected) throw IllegalStateException("not_connected")
+        val live = sgc as? MentraLive ?: throw IllegalStateException("unsupported_device")
+        live.sendCameraFovSetting(null, fov, roiPosition)
+    }
+
+    /** Replays the persistent base FOV without waiting for an acknowledgement. */
+    fun restoreLegacyCameraFovSetting() {
+        val glassesConnected = DeviceStore.get("glasses", "connected") as? Boolean ?: false
+        if (!glassesConnected) throw IllegalStateException("not_connected")
+        val live = sgc as? MentraLive ?: throw IllegalStateException("unsupported_device")
+        live.sendCameraFovSetting()
+    }
+
+    fun sendCameraFovOverride(
+        requestId: String,
+        leaseId: String,
+        fov: Int,
+        roiPosition: Int,
+        ttlMs: Int,
+    ) {
+        val live = sgc as? MentraLive ?: throw IllegalStateException("unsupported_device")
+        live.sendCameraFovOverride(requestId, leaseId, fov, roiPosition, ttlMs)
+    }
+
+    fun releaseCameraFovOverride(requestId: String, leaseId: String) {
+        val live = sgc as? MentraLive ?: throw IllegalStateException("unsupported_device")
+        live.releaseCameraFovOverride(requestId, leaseId)
+    }
+
     fun sendCameraTuningConfig(requestId: String, anrOn: Boolean, gainOn: Boolean) {
         val live = sgc as? MentraLive ?: throw IllegalStateException("unsupported_device")
         live.sendCameraTuningConfig(requestId, anrOn, gainOn)
@@ -1657,8 +1755,11 @@ class DeviceManager {
     fun warmUpCamera(
         requestId: String,
         size: PhotoSize,
+        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.
@@ -1668,11 +1769,16 @@ class DeviceManager {
                     "unsupported_device",
                     "This command requires Mentra Live glasses.",
                 )
-        live.warmUpCamera(requestId, size, exposureTimeNs, durationMs)
+        live.warmUpCamera(requestId, size, mode, exposureTimeNs, durationMs, zsl, mfnr)
+    }
+
+    fun stopCameraWarmUp(requestId: String) {
+        val live = sgc as? MentraLive ?: throw IllegalStateException("unsupported_device")
+        live.stopCameraWarmUp(requestId)
     }
 
     /**
-     * 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> {
@@ -1698,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)
@@ -1830,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()) {
@@ -1843,7 +1955,7 @@ class DeviceManager {
         }
         initSGC(defaultWearable)
         searching = true
-        sgc?.connectById(deviceName)
+        sgc?.connectById(reconnectTarget)
         connectDefaultController()
     }
 
@@ -1938,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(
@@ -1976,6 +2093,7 @@ class DeviceManager {
         Bridge.saveSetting("default_wearable", "")
         Bridge.saveSetting("device_name", "")
         Bridge.saveSetting("device_address", "")
+        Bridge.saveSetting("project_name", "")
     }
 
     fun forgetController() {
@@ -2046,3 +2164,4 @@ class DeviceManager {
         }
     }
 }
+

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

@@ -125,6 +125,7 @@ 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)
@@ -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")