@mentra/bluetooth-sdk 3.2.0-dev.195 → 3.2.0-dev.203

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

@@ -0,0 +1,246 @@
+package com.mentra.bluetoothsdk
+
+internal fun wifiSsidIsValid(ssid: String): Boolean = ssid.trim().isNotEmpty()
+
+/** Validate raw fields before JSON convenience getters can coerce numbers or erase presence. */
+internal fun wifiResponseEnvelopeIsValid(values: Map<String, Any>, allowLegacy: Boolean): Boolean {
+    if (values.containsKey("connected") && values["connected"] !is Boolean) return false
+    if (values.containsKey("dispatched") && values["dispatched"] !is Boolean) return false
+    val hasTuple = listOf("protocol_version", "requestId", "sid").any(values::containsKey)
+    if (!hasTuple) return allowLegacy && !values.containsKey("outcome")
+    return (values["protocol_version"] as? Number)?.toDouble() == 1.0 &&
+        (values["requestId"] as? String)?.isNotBlank() == true &&
+        (values["sid"] as? String)?.isNotBlank() == true &&
+        !values.containsKey("dispatched")
+}
+
+internal const val WIFI_CAPABILITY_NEGOTIATION_TIMEOUT_CODE = "capability_negotiation_timeout"
+
+internal sealed class WifiProtocolCapability {
+    data object Unknown : WifiProtocolCapability()
+
+    data class Supported(val version: Int) : WifiProtocolCapability()
+
+    data object Unsupported : WifiProtocolCapability()
+
+    data object Legacy : WifiProtocolCapability()
+}
+
+internal enum class WifiRequestMode {
+    DISCOVERING,
+    MODERN,
+    LEGACY,
+    UNSUPPORTED,
+}
+
+internal data class WifiSessionRequestSnapshot(
+    val mode: WifiRequestMode,
+    val sessionId: String,
+    val epoch: Long,
+)
+
+internal class WifiSessionCapabilities {
+    var sessionId: String = ""
+        private set
+    var epoch: Long = 0
+        private set
+    var forgetResult: WifiProtocolCapability = WifiProtocolCapability.Unknown
+        private set
+    var savedNetworks: WifiProtocolCapability = WifiProtocolCapability.Unknown
+        private set
+
+    fun reset(sessionId: String = "") {
+        epoch += 1
+        this.sessionId = sessionId
+        forgetResult = WifiProtocolCapability.Unknown
+        savedNetworks = WifiProtocolCapability.Unknown
+    }
+
+    fun applyVersionInfo1(values: Map<String, Any>) {
+        (values["sid"] as? String)?.takeIf { it.isNotEmpty() }?.let { sessionId = it }
+        forgetResult = capability(values["wifiForgetResultVersion"])
+        savedNetworks = capability(values["savedWifiNetworksVersion"])
+    }
+
+    fun forgetMode(): WifiRequestMode = requestMode(forgetResult)
+
+    fun savedNetworksMode(): WifiRequestMode = requestMode(savedNetworks)
+
+    fun savedNetworksRequestSnapshot(): WifiSessionRequestSnapshot =
+        WifiSessionRequestSnapshot(savedNetworksMode(), sessionId, epoch)
+
+    private fun capability(raw: Any?): WifiProtocolCapability {
+        if (raw == null) return WifiProtocolCapability.Legacy
+        return if (raw is Number && raw.toDouble() == 1.0 && sessionId.isNotEmpty()) {
+            WifiProtocolCapability.Supported(1)
+        } else WifiProtocolCapability.Unsupported
+    }
+
+    private fun requestMode(capability: WifiProtocolCapability): WifiRequestMode =
+        when (capability) {
+            WifiProtocolCapability.Unknown -> WifiRequestMode.DISCOVERING
+            is WifiProtocolCapability.Supported -> WifiRequestMode.MODERN
+            WifiProtocolCapability.Legacy -> WifiRequestMode.LEGACY
+            WifiProtocolCapability.Unsupported -> WifiRequestMode.UNSUPPORTED
+        }
+}
+
+enum class WifiForgetOutcome(val wireValue: String) {
+    CONFIRMED("confirmed"),
+    DISPATCHED("dispatched"),
+    NOT_FOUND("not_found"),
+    UNSUPPORTED("unsupported"),
+    FAILED("failed"),
+    LEGACY_UNVERIFIED("legacy_unverified");
+
+    companion object {
+        internal fun fromWire(value: String): WifiForgetOutcome? =
+            entries.find { it.wireValue == value }
+    }
+}
+
+internal fun normalizeWifiForgetResultEvent(
+    requestId: String,
+    sid: String,
+    ssid: String,
+    protocolVersion: Int,
+    outcome: String,
+    legacyDispatched: Boolean?,
+    connected: Boolean?,
+    currentSsid: String,
+    localIp: String,
+    error: String?,
+): Map<String, Any>? {
+    if (!wifiSsidIsValid(ssid)) return null
+    val modernOutcome = WifiForgetOutcome.fromWire(outcome)
+    if (requestId.isNotEmpty() && sid.isNotEmpty() && protocolVersion == 1 &&
+        modernOutcome != null && modernOutcome != WifiForgetOutcome.LEGACY_UNVERIFIED
+    ) {
+        return buildMap {
+            put("mode", "modern")
+            put("requestId", requestId)
+            put("sid", sid)
+            put("ssid", ssid)
+            put("protocolVersion", protocolVersion)
+            put("outcome", modernOutcome.wireValue)
+            connected?.let { put("connected", it) }
+            if (currentSsid.isNotEmpty()) put("currentSsid", currentSsid)
+            if (localIp.isNotEmpty()) put("localIp", localIp)
+            error?.let { put("error", it) }
+        }
+    }
+    if (requestId.isEmpty() && sid.isEmpty() && protocolVersion == 0 && outcome.isEmpty() && legacyDispatched != null) {
+        return buildMap {
+            put("mode", "legacy")
+            put("ssid", ssid)
+            put("dispatched", legacyDispatched)
+            connected?.let { put("connected", it) }
+            if (currentSsid.isNotEmpty()) put("currentSsid", currentSsid)
+            if (localIp.isNotEmpty()) put("localIp", localIp)
+            error?.let { put("error", it) }
+        }
+    }
+    return null
+}
+
+data class WifiForgetResult(
+    val ssid: String,
+    val outcome: WifiForgetOutcome,
+    val connected: Boolean?,
+    val currentSsid: String?,
+    val localIp: String?,
+    val error: String? = null,
+) {
+    internal fun toMap(): Map<String, Any> =
+        buildMap {
+            put("ssid", ssid)
+            put("outcome", outcome.wireValue)
+            connected?.let { put("connected", it) }
+            currentSsid?.let { put("currentSsid", it) }
+            localIp?.let { put("localIp", it) }
+            error?.let { put("error", it) }
+        }
+}
+
+enum class SavedWifiNetworksOutcome(val wireValue: String) {
+    CONFIRMED("confirmed"),
+    UNSUPPORTED("unsupported"),
+    FAILED("failed");
+
+    companion object {
+        internal fun fromWire(value: String): SavedWifiNetworksOutcome? =
+            entries.find { it.wireValue == value }
+    }
+}
+
+data class SavedWifiNetworksResult(
+    val outcome: SavedWifiNetworksOutcome,
+    val networks: List<String>,
+    val error: String? = null,
+) {
+    internal fun toMap(): Map<String, Any> =
+        buildMap {
+            put("outcome", outcome.wireValue)
+            put("networks", networks)
+            error?.let { put("error", it) }
+        }
+}
+
+internal fun parseWifiForgetResult(
+    expectedRequestId: String,
+    expectedSid: String,
+    expectedSsid: String,
+    capabilityVersion: Int,
+    data: Map<String, Any>,
+): WifiForgetResult? {
+    if (capabilityVersion != 1 || expectedRequestId.isEmpty() || expectedSid.isEmpty()) return null
+    if (data["requestId"] as? String != expectedRequestId) return null
+    if (data["sid"] as? String != expectedSid) return null
+    if (data["ssid"] as? String != expectedSsid) return null
+    if ((data["protocolVersion"] as? Number)?.toDouble() != 1.0) return null
+    val outcome = WifiForgetOutcome.fromWire(data["outcome"] as? String ?: return null) ?: return null
+    if (outcome == WifiForgetOutcome.LEGACY_UNVERIFIED) return null
+    return WifiForgetResult(
+        ssid = expectedSsid,
+        outcome = outcome,
+        connected = data["connected"] as? Boolean,
+        currentSsid = data["currentSsid"] as? String,
+        localIp = data["localIp"] as? String,
+        error = (data["error"] as? String)?.takeIf { it.isNotEmpty() },
+    )
+}
+
+internal fun parseSavedWifiNetworks(
+    expectedRequestId: String,
+    expectedSid: String,
+    capabilityVersion: Int,
+    data: Map<String, Any>,
+): SavedWifiNetworksResult? {
+    if (capabilityVersion != 1 || expectedRequestId.isEmpty() || expectedSid.isEmpty()) return null
+    if (data["requestId"] as? String != expectedRequestId) return null
+    if (data["sid"] as? String != expectedSid) return null
+    if ((data["protocolVersion"] as? Number)?.toDouble() != 1.0) return null
+    val outcome =
+        SavedWifiNetworksOutcome.fromWire(data["outcome"] as? String ?: return null) ?: return null
+    val rawNetworks = data["networks"] as? List<*> ?: return null
+    if (rawNetworks.any { it !is String }) return null
+    if (outcome != SavedWifiNetworksOutcome.CONFIRMED && rawNetworks.isNotEmpty()) return null
+    val networks = rawNetworks.map { it as String }.filter { it.trim().isNotEmpty() }.distinct()
+    return SavedWifiNetworksResult(
+        outcome = outcome,
+        networks = networks,
+        error = (data["error"] as? String)?.takeIf { it.isNotEmpty() },
+    )
+}
+
+internal fun legacyWifiForgetResult(
+    ssid: String,
+): WifiForgetResult {
+    return WifiForgetResult(
+        ssid = ssid,
+        outcome = WifiForgetOutcome.LEGACY_UNVERIFIED,
+        connected = null,
+        currentSsid = null,
+        localIp = null,
+    )
+}

package/android/src/main/java/com/mentra/bluetoothsdk/services/Foreground.kt

@@ -3,6 +3,7 @@ package com.mentra.bluetoothsdk.services
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.Service
+import android.content.ComponentName
 import android.content.Intent
 import android.content.pm.PackageManager
 import android.content.pm.ServiceInfo
@@ -21,14 +22,31 @@ class ForegroundService : Service() {
         const val ACTION_REFRESH_TYPES =
                 "com.mentra.bluetoothsdk.services.action.REFRESH_FOREGROUND_SERVICE_TYPES"
 
-        internal fun bootstrapServiceType(): Int =
-                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+        internal const val DEFAULT_SERVICE_TYPES =
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC or
+                        ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE or
+                        ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION or
+                        ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK or
+                        ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE
+
+        internal fun bootstrapServiceType(declaredTypes: Int = DEFAULT_SERVICE_TYPES): Int {
+            // Both types can start without a while-in-use permission. The SDK declares
+            // CHANGE_WIFI_STATE, which satisfies connectedDevice's prerequisite.
+            if (declaredTypes and ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC != 0) {
+                return ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+            }
+            require(declaredTypes and ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE != 0) {
+                "The SDK foreground service must declare connectedDevice or dataSync"
+            }
+            return ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE
+        }
 
         internal fun preferredServiceType(
                 hasConnectedDeviceAccess: Boolean,
                 hasMicrophoneAccess: Boolean,
                 hasLocationAccess: Boolean,
                 includeMediaPlayback: Boolean = true,
+                declaredTypes: Int = DEFAULT_SERVICE_TYPES,
         ): Int {
             var serviceType = 0
 
@@ -47,21 +65,31 @@ class ForegroundService : Service() {
                 serviceType = serviceType or ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION
             }
 
-            return if (serviceType == 0) bootstrapServiceType() else serviceType
+            serviceType = serviceType and declaredTypes
+            return if (serviceType == 0) bootstrapServiceType(declaredTypes) else serviceType
         }
     }
 
     private var locationTypeRequested = false
 
+    private val declaredServiceTypes: Int by lazy {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            packageManager.getServiceInfo(ComponentName(this, ForegroundService::class.java), 0)
+                    .foregroundServiceType
+        } else {
+            DEFAULT_SERVICE_TYPES
+        }
+    }
+
     override fun onCreate() {
         super.onCreate()
         Bridge.log("ForegroundService: onCreate() called")
         BleTraceLogger.logLifecycle(this, "ForegroundService", "service_create")
-        // Enter the foreground immediately with a type that has no runtime
-        // prerequisites. onStartCommand() replaces this bootstrap type with the
+        // Enter the foreground immediately using a type allowed by the host manifest.
+        // onStartCommand() replaces this bootstrap type with the
         // eligible long-running types, deliberately omitting dataSync so Android 15's
         // six-hour dataSync timer no longer applies.
-        startForegroundWithType(bootstrapServiceType())
+        startForegroundWithType(bootstrapServiceType(declaredServiceTypes))
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
@@ -114,12 +142,13 @@ class ForegroundService : Service() {
             return 0 // No service types before Android Q
         }
 
-        // Audio prompts can be initiated by glasses while the host Activity is
-        // backgrounded. mediaPlayback has no runtime prerequisite, so keep it
-        // active on the existing Mentra service for the entire connected
-        // session rather than trying to launch a second service after a wake
-        // phrase arrives.
-        Bridge.log("ForegroundService: Added mediaPlayback (supports background audio)")
+        // MentraOS uses background audio prompts; Bluetooth-only hosts can omit
+        // this type from their merged manifest.
+        val includeMediaPlayback =
+                declaredServiceTypes and ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK != 0
+        if (includeMediaPlayback) {
+            Bridge.log("ForegroundService: Added mediaPlayback (supports background audio)")
+        }
 
         // Check Bluetooth permissions
         val hasBluetoothPermission =
@@ -168,13 +197,14 @@ class ForegroundService : Service() {
 
         // Check microphone permission
         val hasMicPermission =
-                ContextCompat.checkSelfPermission(this, android.Manifest.permission.RECORD_AUDIO) ==
-                        PackageManager.PERMISSION_GRANTED
+                declaredServiceTypes and ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE != 0 &&
+                        ContextCompat.checkSelfPermission(this, android.Manifest.permission.RECORD_AUDIO) ==
+                                PackageManager.PERMISSION_GRANTED
 
         if (hasMicPermission) {
             Bridge.log("ForegroundService: Added microphone (has RECORD_AUDIO permission)")
         } else {
-            Bridge.log("ForegroundService: No microphone permission")
+            Bridge.log("ForegroundService: Microphone type disabled or permission not granted")
         }
 
         val hasLocationPermission =
@@ -189,7 +219,9 @@ class ForegroundService : Service() {
         val locationManager = getSystemService(LocationManager::class.java)
         val isLocationEnabled = locationManager?.isLocationEnabled == true
 
-        val hasLocationAccess = locationTypeRequested && hasLocationPermission && isLocationEnabled
+        val hasLocationAccess =
+                declaredServiceTypes and ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION != 0 &&
+                        locationTypeRequested && hasLocationPermission && isLocationEnabled
         if (hasLocationAccess) {
             Bridge.log("ForegroundService: Added location (has foreground location permission)")
         } else {
@@ -203,6 +235,8 @@ class ForegroundService : Service() {
                 hasConnectedDeviceAccess = hasConnectedDeviceAccess,
                 hasMicrophoneAccess = hasMicPermission,
                 hasLocationAccess = hasLocationAccess,
+                includeMediaPlayback = includeMediaPlayback,
+                declaredTypes = declaredServiceTypes,
         )
     }
 

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

@@ -0,0 +1,104 @@
+package com.mentra.bluetoothsdk.sgcs
+
+internal enum class ClassicAudioProfile {
+    A2DP,
+    HEADSET,
+}
+
+/** A confirmed connection is sufficient; declaring disconnection requires both profile reads. */
+internal fun readyClassicAudioSnapshot(states: Map<ClassicAudioProfile, Boolean>): Set<ClassicAudioProfile>? {
+    val connected = states.filterValues { it }.keys
+    return if (connected.isNotEmpty() || states.size == ClassicAudioProfile.entries.size) connected else null
+}
+
+/**
+ * Tracks the Android Classic audio profiles for one dual-mode glasses device.
+ *
+ * Android reports A2DP and HFP independently. Keeping both states prevents an A2DP disconnect from
+ * publishing a false negative while HFP is still connected. Snapshot tickets reject obsolete
+ * queries, including a previous session with the same MAC address. Broadcast payloads are not truth.
+ */
+internal class ClassicAudioConnectionTracker(
+    private val onConnectedChanged: (Boolean) -> Unit,
+) {
+    private var targetAddress: String? = null
+    private var revision = 0L
+    private val connectedProfiles = mutableSetOf<ClassicAudioProfile>()
+
+    @get:Synchronized
+    val connected: Boolean
+        get() = connectedProfiles.isNotEmpty()
+
+    @Synchronized
+    fun setTarget(address: String) {
+        val normalizedAddress = address.normalizedBluetoothAddress()
+        revision++
+        if (targetAddress == normalizedAddress) return
+
+        targetAddress = normalizedAddress
+        clearConnectedProfiles()
+    }
+
+    @Synchronized
+    fun beginSnapshot(address: String): Long? {
+        if (targetAddress != address.normalizedBluetoothAddress()) return null
+        return ++revision
+    }
+
+    /** Both profile queries must belong to the newest request for this session. */
+    @Synchronized
+    fun applySnapshot(
+        ticket: Long,
+        address: String,
+        profiles: Set<ClassicAudioProfile>,
+        onAccepted: () -> Unit = {},
+    ): Boolean {
+        if (ticket != revision || targetAddress != address.normalizedBluetoothAddress()) return false
+        val wasConnected = this.connected
+        connectedProfiles.clear()
+        connectedProfiles.addAll(profiles)
+        publishIfChanged(wasConnected)
+        // Audio routing notifications must not race a target invalidation after validation.
+        onAccepted()
+        return true
+    }
+
+    @Synchronized
+    fun clear(address: String): Boolean {
+        if (targetAddress != address.normalizedBluetoothAddress()) return false
+        revision++
+        clearConnectedProfiles()
+        return true
+    }
+
+    @Synchronized
+    fun invalidate(address: String): Boolean {
+        if (targetAddress != address.normalizedBluetoothAddress()) return false
+
+        targetAddress = null
+        revision++
+        clearConnectedProfiles()
+        return true
+    }
+
+    @Synchronized
+    fun reset() {
+        targetAddress = null
+        revision++
+        clearConnectedProfiles()
+    }
+
+    private fun clearConnectedProfiles() {
+        val wasConnected = connected
+        connectedProfiles.clear()
+        publishIfChanged(wasConnected)
+    }
+
+    private fun publishIfChanged(wasConnected: Boolean) {
+        if (wasConnected != connected) {
+            onConnectedChanged(connected)
+        }
+    }
+}
+
+private fun String.normalizedBluetoothAddress(): String = trim().uppercase()