@mentra/bluetooth-sdk 3.4.0-dev.996 → 3.4.0-dev.998

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

@@ -0,0 +1,411 @@
+package com.mentra.bluetoothsdk.sgcs
+
+/**
+ * Public Mentra Live pairing state (`MentraLivePairingState` in BluetoothSdk.types.ts).
+ * Mirrors iOS `MentraLivePairingState`.
+ */
+internal sealed class MentraLivePairingState {
+    object Normal : MentraLivePairingState()
+
+    /** The glasses opened a pairing window. Automatic reconnect waits until [endsAtMs] (wall clock). */
+    data class PairingMode(val windowId: Int, val endsAtMs: Long) : MentraLivePairingState()
+
+    /** The glasses no longer accept this phone. Only an explicit pair or a forget clears it. */
+    object Rejected : MentraLivePairingState()
+
+    fun toMap(): Map<String, Any> =
+            when (this) {
+                Normal -> mapOf("state" to "normal")
+                is PairingMode ->
+                        mapOf("state" to "pairing_mode", "windowId" to windowId, "endsAtMs" to endsAtMs)
+                Rejected -> mapOf("state" to "pairing_rejected")
+            }
+}
+
+/** What the connection manager must do after a [MentraLivePairingStateMachine] input. */
+internal enum class MentraLivePairingEffect {
+    NONE,
+    /** Leave the link and make no automatic connection until resumed. */
+    PAUSE,
+    /** The window is over: reconnect to the saved glasses. */
+    RESUME,
+    /** Stop reconnecting. The glasses belong to another phone. */
+    REJECT,
+}
+
+internal data class MentraLivePairingTransition(
+        val effect: MentraLivePairingEffect,
+        val stateChanged: Boolean,
+        val note: String,
+)
+
+/**
+ * Pairing-mode pause/resume, takeover detection and rejection detection for one saved Mentra Live
+ * (pairing spec "Ownership transfer v4"). Pure and clock-free: every input carries `nowMs`
+ * (wall clock, because the pause deadline survives a process restart). Mirrors iOS
+ * `MentraLivePairingStateMachine` input for input.
+ */
+internal class MentraLivePairingStateMachine {
+    companion object {
+        /** Glasses flag-clear advertisements seen this soon after the notice can predate the window. */
+        const val FLAG_CLEAR_GRACE_MS = 3_000L
+
+        /** A pairing-mode advertisement this recent still means the glasses are in pairing mode. */
+        const val PAIRING_ADVERT_FRESH_MS = 10_000L
+
+        /** Window id used when protocol-3 firmware sends `owner_retained` without `window_id`. */
+        const val UNKNOWN_WINDOW_ID = -1
+
+        const val KEY_DEVICE_ID = "pairing_v4_device_id"
+        const val KEY_STATE = "pairing_v4_state"
+        const val KEY_WINDOW_ID = "pairing_v4_window_id"
+        const val KEY_ENDS_AT_MS = "pairing_v4_ends_at_ms"
+        const val KEY_PAUSE_MS = "pairing_v4_pause_ms"
+        const val KEY_ENDED_WINDOW_ID = "pairing_v4_ended_window_id"
+        const val KEY_VERIFIED_WINDOW_ID = "pairing_v4_verified_window_id"
+        val KEYS =
+                listOf(
+                        KEY_DEVICE_ID,
+                        KEY_STATE,
+                        KEY_WINDOW_ID,
+                        KEY_ENDS_AT_MS,
+                        KEY_PAUSE_MS,
+                        KEY_ENDED_WINDOW_ID,
+                        KEY_VERIFIED_WINDOW_ID,
+                )
+
+        /** Pre-v4 stand-down phase. Its presence migrates to [MentraLivePairingState.Rejected]. */
+        const val LEGACY_REJECTION_PHASE_KEY = "previous_owner_rejection_phase"
+        val LEGACY_KEYS =
+                listOf(
+                        LEGACY_REJECTION_PHASE_KEY,
+                        "previous_owner_rejection_generation",
+                        "pairing_yield_until_wall_ms",
+                )
+
+        private const val STATE_PAIRING_MODE = "pairing_mode"
+        private const val STATE_REJECTED = "pairing_rejected"
+
+        private fun intValue(value: Any?): Int? = (value as? Number)?.toInt()
+
+        private fun longValue(value: Any?): Long? = (value as? Number)?.toLong()
+    }
+
+    var state: MentraLivePairingState = MentraLivePairingState.Normal
+        private set
+
+    /** Saved glasses this record belongs to. Empty until known. */
+    var deviceId: String = ""
+        private set
+
+    /** The next connection attempt is the one verification after an `OWNER_CHANGED` advertisement. */
+    var verificationArmed: Boolean = false
+        private set
+
+    /** The window this phone paused for and that has ended. Read against `OWNER_CHANGED`. */
+    var endedWindowId: Int? = null
+        private set
+
+    private var pauseMs = 0L
+    private var pausedAtMs: Long? = null
+    private var verifiedWindowId: Int? = null
+    private var lastPairingAdvertAtMs: Long? = null
+    private var takeoverAdvertRead = false
+    private val streak = MentraLiveOwnerLossPolicy.OwnerRejectionStreak()
+
+    val allowsAutomaticReconnect: Boolean
+        get() = state == MentraLivePairingState.Normal
+
+    /**
+     * A window this phone paused for has ended and no post-window advertisement has been read,
+     * so a reconnect should scan first instead of dialing the saved address directly.
+     */
+    val awaitingTakeoverCheck: Boolean
+        get() = state == MentraLivePairingState.Normal && endedWindowId != null && !takeoverAdvertRead
+
+    val isPaused: Boolean
+        get() = state is MentraLivePairingState.PairingMode
+
+    fun remainingPauseMs(nowMs: Long): Long =
+            (state as? MentraLivePairingState.PairingMode)?.let { maxOf(0L, it.endsAtMs - nowMs) } ?: 0L
+
+    /**
+     * Rebuild from persisted values. Unknown keys and malformed values are ignored. A record for
+     * other glasses, or a pause whose deadline passed or is implausible, does not survive.
+     */
+    fun restore(values: Map<String, *>, savedDeviceId: String, nowMs: Long): MentraLivePairingTransition {
+        resetInMemory()
+        state = MentraLivePairingState.Normal
+        deviceId = values[KEY_DEVICE_ID] as? String ?: ""
+        endedWindowId = intValue(values[KEY_ENDED_WINDOW_ID])
+        verifiedWindowId = intValue(values[KEY_VERIFIED_WINDOW_ID])
+        if (savedDeviceId.isNotEmpty() && deviceId.isNotEmpty() && deviceId != savedDeviceId) {
+            clearRecord()
+            deviceId = savedDeviceId
+            return none("record belongs to other glasses")
+        }
+        when (values[KEY_STATE] as? String) {
+            STATE_REJECTED -> {
+                state = MentraLivePairingState.Rejected
+                return MentraLivePairingTransition(MentraLivePairingEffect.REJECT, true, "restored rejected")
+            }
+            STATE_PAIRING_MODE -> {
+                val windowId = intValue(values[KEY_WINDOW_ID])
+                val endsAtMs = longValue(values[KEY_ENDS_AT_MS]) ?: 0L
+                val pause =
+                        longValue(values[KEY_PAUSE_MS])
+                                ?: MentraLiveOwnerLossPolicy.yieldMs(
+                                        MentraLiveOwnerLossPolicy.DEFAULT_PAIRING_WINDOW_MS
+                                )
+                val remaining = MentraLiveOwnerLossPolicy.persistedYieldRemainingMs(endsAtMs, nowMs, pause)
+                if (windowId != null && remaining > 0L) {
+                    state = MentraLivePairingState.PairingMode(windowId, endsAtMs)
+                    pauseMs = pause
+                    return MentraLivePairingTransition(
+                            MentraLivePairingEffect.PAUSE,
+                            true,
+                            "restored pairing_mode window=$windowId remaining=${remaining}ms",
+                    )
+                }
+                if (windowId != null) endedWindowId = windowId
+                return none("persisted pause ended while the app was away")
+            }
+        }
+        if (values[LEGACY_REJECTION_PHASE_KEY] is String) {
+            state = MentraLivePairingState.Rejected
+            return MentraLivePairingTransition(MentraLivePairingEffect.REJECT, true, "migrated legacy stand-down")
+        }
+        return none("restored normal")
+    }
+
+    /** The current record, keyed by [KEYS]. */
+    fun persisted(): Map<String, Any> {
+        val values = mutableMapOf<String, Any>()
+        if (deviceId.isNotEmpty()) values[KEY_DEVICE_ID] = deviceId
+        when (val current = state) {
+            is MentraLivePairingState.PairingMode -> {
+                values[KEY_STATE] = STATE_PAIRING_MODE
+                values[KEY_WINDOW_ID] = current.windowId
+                values[KEY_ENDS_AT_MS] = current.endsAtMs
+                values[KEY_PAUSE_MS] = pauseMs
+            }
+            MentraLivePairingState.Rejected -> values[KEY_STATE] = STATE_REJECTED
+            MentraLivePairingState.Normal -> Unit
+        }
+        endedWindowId?.let { values[KEY_ENDED_WINDOW_ID] = it }
+        // Armed verification is not persisted, so a window counts as verified only once its
+        // verification has been used. After a restart the next OWNER_CHANGED advert re-arms it.
+        if (!verificationArmed) verifiedWindowId?.let { values[KEY_VERIFIED_WINDOW_ID] = it }
+        return values
+    }
+
+    /** An automatic connect to [id]. A record for other glasses no longer applies. */
+    fun bindDevice(id: String): MentraLivePairingTransition {
+        if (id.isEmpty() || id == deviceId) return none("same glasses")
+        val hadRecord = deviceId.isNotEmpty()
+        val wasNormal = state == MentraLivePairingState.Normal
+        if (hadRecord) clearRecord()
+        deviceId = id
+        return MentraLivePairingTransition(
+                MentraLivePairingEffect.NONE,
+                hadRecord && !wasNormal,
+                if (hadRecord) "record moved to other glasses" else "bound",
+        )
+    }
+
+    /**
+     * `entering_pairing_mode`. Protocol 4 (`window_id`) pauses this phone for the window plus a
+     * margin. Firmware without ownership transfer forgets this phone on entry (pairing spec R4),
+     * so a notice without `window_id` or `owner_retained` means the glasses dropped it.
+     */
+    fun onEnteringPairingMode(
+            windowMs: Long?,
+            windowId: Int?,
+            ownerRetained: Boolean,
+            explicitAttempt: Boolean,
+            deviceId: String,
+            nowMs: Long,
+    ): MentraLivePairingTransition {
+        if (deviceId.isNotEmpty()) this.deviceId = deviceId
+        if (explicitAttempt) return none("notice during an explicit attempt")
+        if (windowId == null && !ownerRetained) return reject("forget_on_entry")
+        val id = windowId ?: UNKNOWN_WINDOW_ID
+        val current = state
+        if (current is MentraLivePairingState.PairingMode && current.windowId == id) {
+            return none("duplicate notice for window $id")
+        }
+        val pause = MentraLiveOwnerLossPolicy.yieldMs(windowMs ?: 0L)
+        state = MentraLivePairingState.PairingMode(id, nowMs + pause)
+        pauseMs = pause
+        pausedAtMs = nowMs
+        endedWindowId = null
+        verificationArmed = false
+        streak.reset()
+        return MentraLivePairingTransition(
+                MentraLivePairingEffect.PAUSE,
+                true,
+                "pairing_mode window=$id pause=${pause}ms",
+        )
+    }
+
+    /**
+     * `pairing_mode_ended`. Only a connected phone receives it, so the glasses still admit this
+     * phone and there is no takeover to check.
+     */
+    fun onPairingModeEnded(reason: String?, windowId: Int?): MentraLivePairingTransition {
+        val current = state as? MentraLivePairingState.PairingMode ?: return none("not paused")
+        if (windowId != null && current.windowId != UNKNOWN_WINDOW_ID && windowId != current.windowId) {
+            return none("ended window $windowId is not ${current.windowId}")
+        }
+        state = MentraLivePairingState.Normal
+        pausedAtMs = null
+        endedWindowId = null
+        return MentraLivePairingTransition(
+                MentraLivePairingEffect.RESUME,
+                true,
+                "pairing_mode_ended reason=${reason ?: ""}",
+        )
+    }
+
+    /**
+     * An advertisement from the saved glasses carrying the secure trailer. A cleared pairing flag
+     * ends the pause early. After the window this phone paused for, `OWNER_CHANGED` for that
+     * window arms exactly one verification attempt.
+     */
+    fun onAdvertisement(
+            pairingMode: Boolean,
+            ownerChanged: Boolean,
+            generation: Int?,
+            nowMs: Long,
+    ): MentraLivePairingTransition {
+        lastPairingAdvertAtMs = if (pairingMode) nowMs else null
+        var effect = MentraLivePairingEffect.NONE
+        var changed = false
+        val notes = mutableListOf<String>()
+        val current = state
+        if (current is MentraLivePairingState.PairingMode && !pairingMode) {
+            val sincePause = pausedAtMs?.let { nowMs - it } ?: Long.MAX_VALUE
+            if (sincePause >= FLAG_CLEAR_GRACE_MS) {
+                state = MentraLivePairingState.Normal
+                pausedAtMs = null
+                endedWindowId = current.windowId
+                effect = MentraLivePairingEffect.RESUME
+                changed = true
+                notes += "pairing flag cleared"
+            }
+        }
+        if (state == MentraLivePairingState.Normal && !pairingMode && endedWindowId != null) {
+            takeoverAdvertRead = true
+            if (ownerChanged &&
+                            generation != null &&
+                            generation == endedWindowId &&
+                            verifiedWindowId != generation
+            ) {
+                verificationArmed = true
+                verifiedWindowId = generation
+                notes += "owner_changed for window $generation — one verification attempt"
+            }
+        }
+        return MentraLivePairingTransition(effect, changed, notes.joinToString("; ").ifEmpty { "advert" })
+    }
+
+    /** The pause deadline may have passed. */
+    fun onTick(nowMs: Long): MentraLivePairingTransition {
+        val current = state as? MentraLivePairingState.PairingMode ?: return none("not paused")
+        if (nowMs < current.endsAtMs) return none("pause continues")
+        state = MentraLivePairingState.Normal
+        pausedAtMs = null
+        endedWindowId = current.windowId
+        takeoverAdvertRead = false
+        return MentraLivePairingTransition(MentraLivePairingEffect.RESUME, true, "pause deadline passed")
+    }
+
+    /**
+     * One authentication-type failure (Android HCI 0x05/0x0F or bond removed, iOS CBError 14 or
+     * insufficient authentication/encryption). The intentional disconnect at window entry, the
+     * glasses' 0x14 refusals and anything while pairing mode is in effect never count.
+     */
+    fun onAuthRejection(
+            secureFirmware: Boolean,
+            explicitAttempt: Boolean,
+            nowMs: Long,
+    ): MentraLivePairingTransition {
+        if (!secureFirmware) return none("legacy firmware")
+        if (explicitAttempt) return none("explicit attempt")
+        when (state) {
+            is MentraLivePairingState.PairingMode -> return none("pairing_mode in effect")
+            MentraLivePairingState.Rejected -> return none("already rejected")
+            MentraLivePairingState.Normal -> Unit
+        }
+        if (advertShowsPairingMode(nowMs)) return none("advertisement shows pairing mode")
+        if (verificationArmed) {
+            return reject("owner_changed_verification_failed")
+        }
+        if (!streak.record(nowMs)) return none("counted toward the rejection streak")
+        return reject("auth_rejection_streak")
+    }
+
+    /** The verification attempt ended without an authentication verdict. */
+    fun onConnectAttemptFailed(): MentraLivePairingTransition {
+        if (!verificationArmed) return none("no verification")
+        verificationArmed = false
+        return none("verification attempt failed without an auth verdict")
+    }
+
+    /** A session reached ready. An explicit pair clears [MentraLivePairingState.Rejected]. */
+    fun onSessionReady(explicitAttempt: Boolean): MentraLivePairingTransition {
+        streak.reset()
+        verificationArmed = false
+        endedWindowId = null
+        lastPairingAdvertAtMs = null
+        val current = state
+        val clear =
+                current is MentraLivePairingState.PairingMode ||
+                        (explicitAttempt && current == MentraLivePairingState.Rejected)
+        if (!clear) return none("ready")
+        state = MentraLivePairingState.Normal
+        pausedAtMs = null
+        return MentraLivePairingTransition(
+                MentraLivePairingEffect.NONE,
+                true,
+                if (explicitAttempt) "explicit pair succeeded" else "glasses admitted this phone",
+        )
+    }
+
+    fun onForget(): MentraLivePairingTransition {
+        val changed = state != MentraLivePairingState.Normal
+        clearRecord()
+        deviceId = ""
+        return MentraLivePairingTransition(MentraLivePairingEffect.NONE, changed, "forget")
+    }
+
+    private fun advertShowsPairingMode(nowMs: Long): Boolean =
+            lastPairingAdvertAtMs?.let { nowMs - it in 0..PAIRING_ADVERT_FRESH_MS } == true
+
+    private fun reject(reason: String): MentraLivePairingTransition {
+        state = MentraLivePairingState.Rejected
+        pausedAtMs = null
+        endedWindowId = null
+        verificationArmed = false
+        streak.reset()
+        return MentraLivePairingTransition(MentraLivePairingEffect.REJECT, true, reason)
+    }
+
+    private fun clearRecord() {
+        resetInMemory()
+        state = MentraLivePairingState.Normal
+        endedWindowId = null
+        verifiedWindowId = null
+    }
+
+    private fun resetInMemory() {
+        pauseMs = 0L
+        pausedAtMs = null
+        verificationArmed = false
+        lastPairingAdvertAtMs = null
+        takeoverAdvertRead = false
+        streak.reset()
+    }
+
+    private fun none(note: String) = MentraLivePairingTransition(MentraLivePairingEffect.NONE, false, note)
+}

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

@@ -0,0 +1,124 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.content.Context
+import androidx.annotation.VisibleForTesting
+import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.DeviceStore
+
+/**
+ * Process-wide owner of the [MentraLivePairingStateMachine]. It outlives each [MentraLive]
+ * instance so a disconnect or SGC replacement keeps the pause and the rejection, persists the
+ * record natively (never through the replayed settings), and publishes
+ * `GlassesStatus.pairingState` plus `pairing_state_changed`.
+ */
+internal object MentraLivePairingStateStore {
+    private const val PREFS = "mentra_live_owner"
+
+    private var machine = MentraLivePairingStateMachine()
+    private var restored = false
+
+    /** Drops the in-memory state as a process restart would. Persisted values stay. */
+    @VisibleForTesting
+    @Synchronized
+    internal fun resetForTest() {
+        machine = MentraLivePairingStateMachine()
+        restored = false
+    }
+
+    val state: MentraLivePairingState
+        @Synchronized get() = machine.state
+
+    val allowsAutomaticReconnect: Boolean
+        @Synchronized get() = machine.allowsAutomaticReconnect
+
+    val isPaused: Boolean
+        @Synchronized get() = machine.isPaused
+
+    val isRejected: Boolean
+        @Synchronized get() = machine.state == MentraLivePairingState.Rejected
+
+    val verificationArmed: Boolean
+        @Synchronized get() = machine.verificationArmed
+
+    /** A window this phone paused for ended and its advertisement has not been read yet. */
+    val awaitingTakeoverCheck: Boolean
+        @Synchronized get() = machine.awaitingTakeoverCheck
+
+    @Synchronized
+    fun remainingPauseMs(nowMs: Long = System.currentTimeMillis()): Long = machine.remainingPauseMs(nowMs)
+
+    /** Restore once per process. Later calls only republish. */
+    @Synchronized
+    fun ensureRestored(savedDeviceId: String, nowMs: Long = System.currentTimeMillis()): MentraLivePairingTransition? {
+        if (restored) {
+            publish(emitEvent = false)
+            return null
+        }
+        restored = true
+        val prefs = prefs()
+        val values = prefs?.all ?: emptyMap<String, Any?>()
+        val transition = machine.restore(values, savedDeviceId, nowMs)
+        prefs?.edit()?.apply {
+            MentraLivePairingStateMachine.LEGACY_KEYS.forEach { remove(it) }
+            apply()
+        }
+        persist()
+        publish()
+        Bridge.log("PAIRFLOW: pairing_state restore note=${transition.note} state=${describe()}")
+        return transition
+    }
+
+    /** Run one machine input, persist the record, and publish when the public state changed. */
+    @Synchronized
+    fun update(
+            source: String,
+            input: (MentraLivePairingStateMachine) -> MentraLivePairingTransition,
+    ): MentraLivePairingTransition {
+        val before = machine.state
+        val beforeRecord = machine.persisted()
+        val transition = input(machine)
+        // Duplicate-reporting scans feed every advertisement through here.
+        if (machine.persisted() != beforeRecord) persist()
+        if (machine.state != before) publish()
+        if (transition.effect != MentraLivePairingEffect.NONE || machine.state != before) {
+            Bridge.log(
+                    "PAIRFLOW: pairing_state source=$source effect=${transition.effect} " +
+                            "note=${transition.note} state=${describe()}"
+            )
+        }
+        return transition
+    }
+
+    @Synchronized
+    fun describe(): String =
+            when (val current = machine.state) {
+                MentraLivePairingState.Normal -> "normal"
+                is MentraLivePairingState.PairingMode ->
+                        "pairing_mode(window=${current.windowId}, endsAtMs=${current.endsAtMs})"
+                MentraLivePairingState.Rejected -> "pairing_rejected"
+            }
+
+    private fun persist() {
+        val prefs = prefs() ?: return
+        val editor = prefs.edit()
+        MentraLivePairingStateMachine.KEYS.forEach { editor.remove(it) }
+        machine.persisted().forEach { (key, value) ->
+            when (value) {
+                is Int -> editor.putInt(key, value)
+                is Long -> editor.putLong(key, value)
+                is String -> editor.putString(key, value)
+                is Boolean -> editor.putBoolean(key, value)
+            }
+        }
+        editor.apply()
+    }
+
+    private fun publish(emitEvent: Boolean = true) {
+        val map = machine.state.toMap()
+        DeviceStore.apply("glasses", "pairingState", map)
+        if (emitEvent) Bridge.sendTypedMessage("pairing_state_changed", mapOf("state" to map))
+    }
+
+    private fun prefs() =
+            Bridge.getContext()?.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+}

package/android/src/main/java/com/mentra/bluetoothsdk/status/DeviceStatus.kt

@@ -1,5 +1,8 @@
 package com.mentra.bluetoothsdk
 
+import com.mentra.bluetoothsdk.sgcs.GlassesAudioSetupPolicy
+import com.mentra.bluetoothsdk.sgcs.GlassesAudioSetupState
+
 data class WifiScanResult(
     val ssid: String,
     val requiresPassword: Boolean,
@@ -35,6 +38,8 @@ internal data class GlassesStatus(
     val voiceActivityDetectionEnabled: Boolean,
     val connectionState: GlassesConnectionState,
     val bluetoothClassicConnected: Boolean,
+    val bluetoothClassicProfilesConnected: Boolean,
+    val bluetoothAudioRouted: Boolean,
     val signalStrength: Int,
     val signalStrengthUpdatedAt: Long,
     val deviceModel: String,
@@ -77,6 +82,14 @@ internal data class GlassesStatus(
     val controllerBatteryLevel: Int,
     val controllerSignalStrength: Int,
     val ringSignalStrength: Int,
+    /** Mentra Live `MentraLivePairingState` map (`{state, windowId?, endsAtMs?}`); absent for other glasses. */
+    val pairingState: Map<String, Any>? = null,
+    /**
+     * `GlassesAudioSetupState` map, on every model. Derived from [fullyBooted] by
+     * [GlassesAudioSetupPolicy] rather than stored, so a snapshot that reports ready never
+     * carries a stale `idle`.
+     */
+    val audioSetup: Map<String, Any> = GlassesAudioSetupPolicy.state(fullyBooted).toMap(),
 ) {
     internal fun toMap(): Map<String, Any> {
         val values =
@@ -85,6 +98,8 @@ internal data class GlassesStatus(
             "micEnabled" to micEnabled,
             "voiceActivityDetectionEnabled" to voiceActivityDetectionEnabled,
             "bluetoothClassicConnected" to bluetoothClassicConnected,
+            "bluetoothClassicProfilesConnected" to bluetoothClassicProfilesConnected,
+            "bluetoothAudioRouted" to bluetoothAudioRouted,
             "signalStrength" to signalStrength,
             "signalStrengthUpdatedAt" to signalStrengthUpdatedAt,
             "deviceModel" to deviceModel,
@@ -123,6 +138,8 @@ internal data class GlassesStatus(
             "ringSignalStrength" to ringSignalStrength,
         )
         systemTimeMs?.let { values["systemTimeMs"] = it }
+        pairingState?.let { values["pairingState"] = it }
+        values["audioSetup"] = audioSetup
         return values
     }
 
@@ -137,6 +154,9 @@ internal data class GlassesStatus(
                         ?: BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED,
                 connectionState = GlassesConnectionState.fromValue(stringValue(values, "connectionState")),
                 bluetoothClassicConnected = boolValue(values, "bluetoothClassicConnected") ?: false,
+                // Android has no separate profile/route signal; both mirror the Classic audio state.
+                bluetoothClassicProfilesConnected = boolValue(values, "bluetoothClassicConnected") ?: false,
+                bluetoothAudioRouted = boolValue(values, "bluetoothClassicConnected") ?: false,
                 signalStrength = numberValue(values, "signalStrength") ?: -1,
                 signalStrengthUpdatedAt = longValue(values, "signalStrengthUpdatedAt") ?: 0L,
                 deviceModel = stringValue(values, "deviceModel") ?: "",
@@ -174,10 +194,25 @@ internal data class GlassesStatus(
                 controllerBatteryLevel = numberValue(values, "controllerBatteryLevel") ?: -1,
                 controllerSignalStrength = numberValue(values, "controllerSignalStrength") ?: -1,
                 ringSignalStrength = numberValue(values, "ringSignalStrength") ?: -1,
+                pairingState = pairingStateValue(values),
             )
     }
 }
 
+/** `audioSetup` from an event or update map, keeping only a known state and its action. */
+internal fun audioSetupValue(values: Map<String, Any>): Map<String, Any>? =
+    GlassesAudioSetupState.fromMap(values["audioSetup"])?.toMap()
+
+/** `pairingState` from a store or event map, keeping only string keys. */
+internal fun pairingStateValue(values: Map<String, Any>): Map<String, Any>? {
+    val raw = values["pairingState"] as? Map<*, *> ?: return null
+    val state = raw["state"] as? String ?: return null
+    val result = mutableMapOf<String, Any>("state" to state)
+    (raw["windowId"] as? Number)?.let { result["windowId"] = it.toInt() }
+    (raw["endsAtMs"] as? Number)?.let { result["endsAtMs"] = it.toLong() }
+    return result
+}
+
 data class VersionInfoResult(
     val androidVersion: String,
     val firmwareVersion: String,
@@ -406,6 +441,8 @@ internal data class GlassesStatusUpdate(
     val voiceActivityDetectionEnabled: Boolean? = null,
     val connectionState: GlassesConnectionState? = null,
     val bluetoothClassicConnected: Boolean? = null,
+    val bluetoothClassicProfilesConnected: Boolean? = null,
+    val bluetoothAudioRouted: Boolean? = null,
     val signalStrength: Int? = null,
     val signalStrengthUpdatedAt: Long? = null,
     val deviceModel: String? = null,
@@ -442,6 +479,9 @@ internal data class GlassesStatusUpdate(
     val controllerBatteryLevel: Int? = null,
     val controllerSignalStrength: Int? = null,
     val ringSignalStrength: Int? = null,
+    val pairingState: Map<String, Any>? = null,
+    /** Explicit `GlassesAudioSetupState` map. When absent, an update that sets [fullyBooted] carries the matching state. */
+    val audioSetup: Map<String, Any>? = null,
 ) {
     internal fun toMap(): Map<String, Any> =
         buildMap {
@@ -458,6 +498,8 @@ internal data class GlassesStatusUpdate(
             putIfNotNull("micEnabled", micEnabled)
             putIfNotNull("voiceActivityDetectionEnabled", voiceActivityDetectionEnabled)
             putIfNotNull("bluetoothClassicConnected", bluetoothClassicConnected)
+            putIfNotNull("bluetoothClassicProfilesConnected", bluetoothClassicProfilesConnected)
+            putIfNotNull("bluetoothAudioRouted", bluetoothAudioRouted)
             putIfNotNull("signalStrength", signalStrength)
             putIfNotNull("signalStrengthUpdatedAt", signalStrengthUpdatedAt)
             putIfNotNull("deviceModel", deviceModel)
@@ -498,6 +540,10 @@ internal data class GlassesStatusUpdate(
             putIfNotNull("controllerBatteryLevel", controllerBatteryLevel)
             putIfNotNull("controllerSignalStrength", controllerSignalStrength)
             putIfNotNull("ringSignalStrength", ringSignalStrength)
+            pairingState?.let { put("pairingState", it) }
+            (audioSetup ?: fullyBooted?.let { GlassesAudioSetupPolicy.state(it).toMap() })?.let {
+                put("audioSetup", it)
+            }
         }
 
     companion object {
@@ -509,6 +555,8 @@ internal data class GlassesStatusUpdate(
                 voiceActivityDetectionEnabled = optionalBoolValue(values, "voiceActivityDetectionEnabled"),
                 connectionState = GlassesConnectionState.optionalFromValue(optionalStringValue(values, "connectionState")),
                 bluetoothClassicConnected = optionalBoolValue(values, "bluetoothClassicConnected"),
+                bluetoothClassicProfilesConnected = optionalBoolValue(values, "bluetoothClassicProfilesConnected"),
+                bluetoothAudioRouted = optionalBoolValue(values, "bluetoothAudioRouted"),
                 signalStrength = optionalNumberValue(values, "signalStrength"),
                 signalStrengthUpdatedAt = optionalLongValue(values, "signalStrengthUpdatedAt"),
                 deviceModel = optionalStringValue(values, "deviceModel"),
@@ -559,6 +607,8 @@ internal data class GlassesStatusUpdate(
                 controllerBatteryLevel = optionalNumberValue(values, "controllerBatteryLevel"),
                 controllerSignalStrength = optionalNumberValue(values, "controllerSignalStrength"),
                 ringSignalStrength = optionalNumberValue(values, "ringSignalStrength"),
+                pairingState = pairingStateValue(values),
+                audioSetup = audioSetupValue(values),
             )
     }
 }