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

package/ios/Source/DeviceManager.swift

@@ -85,6 +85,8 @@ struct ViewState {
         // Check if device is paired (don't activate to preserve A2DP music playback)
         let isPaired = AudioSessionMonitor.isDevicePaired(devicePattern: audioDevicePattern)
 
+        publishClassicAudioProfiles(devicePattern: audioDevicePattern)
+
         if isPaired {
             // Device is paired! Don't activate it - let PhoneMic.swift activate when recording starts
             Bridge.log("Audio: Mentra Live is paired (preserving A2DP for music)")
@@ -98,6 +100,7 @@ struct ViewState {
             AudioSessionMonitor.startMonitoring(devicePattern: audioDevicePattern) {
                 [weak self] (connected: Bool, _: String?) in
                 guard let self = self else { return }
+                self.publishClassicAudioProfiles(devicePattern: audioDevicePattern)
 
                 if connected {
                     Bridge.log("Audio: Device paired and connected")
@@ -133,6 +136,22 @@ struct ViewState {
         set { DeviceStore.shared.apply("bluetooth", "default_wearable", newValue) }
     }
 
+    /// Clears the retired pre-v4 owner-lost setting. The Mentra Live pairing state is native
+    /// (`MentraLivePairingStateStore`) and never rides the settings replay.
+    private func clearOwnerLost() {
+        guard DeviceStore.shared.get("bluetooth", "mentra_live_owner_lost") as? Bool == true else { return }
+        DeviceStore.shared.apply("bluetooth", "mentra_live_owner_lost", false)
+        Bridge.saveSetting("mentra_live_owner_lost", false)
+    }
+
+    /// The saved glasses' firmware is no longer known once they are forgotten. The next glasses
+    /// report it again with their first `pairing_info`.
+    private func clearSecureFirmware() {
+        guard DeviceStore.shared.get("bluetooth", "mentra_live_secure_firmware") as? Bool == true else { return }
+        DeviceStore.shared.apply("bluetooth", "mentra_live_secure_firmware", false)
+        Bridge.saveSetting("mentra_live_secure_firmware", false)
+    }
+
     private var pendingWearable: String {
         get { DeviceStore.shared.get("bluetooth", "pending_wearable") as? String ?? "" }
         set { DeviceStore.shared.apply("bluetooth", "pending_wearable", newValue) }
@@ -253,6 +272,26 @@ struct ViewState {
         set { DeviceStore.shared.apply("glasses", "bluetoothClassicConnected", newValue) }
     }
 
+    /// An HFP input is available or a matching Bluetooth output is active.
+    private var glassesBluetoothClassicProfilesConnected: Bool {
+        get { DeviceStore.shared.get("glasses", "bluetoothClassicProfilesConnected") as? Bool ?? false }
+        set { DeviceStore.shared.apply("glasses", "bluetoothClassicProfilesConnected", newValue) }
+    }
+
+    /// A matching Bluetooth output is the active audio route.
+    private var glassesBluetoothAudioRouted: Bool {
+        get { DeviceStore.shared.get("glasses", "bluetoothAudioRouted") as? Bool ?? false }
+        set { DeviceStore.shared.apply("glasses", "bluetoothAudioRouted", newValue) }
+    }
+
+    #if !os(macOS)
+    private func publishClassicAudioProfiles(devicePattern: String) {
+        let profiles = AudioSessionMonitor.observeProfiles(devicePattern: devicePattern)
+        glassesBluetoothClassicProfilesConnected = profiles.profilesConnected
+        glassesBluetoothAudioRouted = profiles.audioRouted
+    }
+    #endif
+
     private var micRanking: [String] {
         get {
             DeviceStore.shared.get("bluetooth", "micRanking") as? [String] ?? MicMap.map["auto"]!
@@ -943,17 +982,23 @@ struct ViewState {
 
         if audioDevicePattern.isEmpty || audioDevicePattern == DeviceTypes.SIMULATED {
             glassesBluetoothClassicConnected = false
+            glassesBluetoothClassicProfilesConnected = false
+            glassesBluetoothAudioRouted = false
             Bridge.log("MAN: Audio device pattern is empty or simulated, returning")
             return
         }
 
         #if os(macOS)
         glassesBluetoothClassicConnected = AudioSessionMonitor.isAudioDeviceConnected(devicePattern: audioDevicePattern)
+        // macOS only sees active audio devices, so every fact collapses to the same value.
+        glassesBluetoothClassicProfilesConnected = glassesBluetoothClassicConnected
+        glassesBluetoothAudioRouted = glassesBluetoothClassicConnected
         otherBtConnected = AudioSessionMonitor.isOtherAudioDeviceConnected(devicePattern: audioDevicePattern)
         #else
         // A connected HFP input remains eligible even while another output is
         // selected. Inspect available inputs as well as the active A2DP route.
         glassesBluetoothClassicConnected = AudioSessionMonitor.isDevicePaired(devicePattern: audioDevicePattern)
+        publishClassicAudioProfiles(devicePattern: audioDevicePattern)
         otherBtConnected = AudioSessionMonitor.isOtherAudioDeviceConnected(devicePattern: audioDevicePattern)
         #endif
     }
@@ -1876,9 +1921,18 @@ struct ViewState {
         }
         initSGC(defaultWearable)
         (sgc as? MentraLive)?.setRequiresAncs(requiresAncs)
-        if let live = sgc as? MentraLive, live.isPairingYieldActive() {
-            Bridge.log("MAN: connectDefault skipped — Mentra Live pairing yield active")
-            return
+        if let live = sgc as? MentraLive {
+            let pairingState = MentraLivePairingStateStore.shared
+            if pairingState.isRejected {
+                Bridge.log("MAN: connectDefault skipped — Mentra Live pairing_rejected (Pair Again or forget)")
+                return
+            }
+            if pairingState.isPaused {
+                // The manager watches the advertisement and resumes on its own.
+                Bridge.log("MAN: connectDefault deferred — Mentra Live pairing_mode")
+                live.connectById(reconnectTarget)
+                return
+            }
         }
         searching = true
         sgc?.connectById(reconnectTarget)
@@ -1900,22 +1954,22 @@ struct ViewState {
     }
 
     func connectByName(_ dName: String, requiresAncs: Bool = true) {
-        Bridge.log("MAN: Connecting to wearable: \(dName)")
         var name = dName
 
         // use stored device name if available:
         if dName.isEmpty && !deviceName.isEmpty {
             name = deviceName
         }
+        Bridge.log("PAIRFLOW: connect_by_name requested=\(dName) resolved=\(name)")
 
         if pendingWearable.isEmpty, defaultWearable.isEmpty {
-            Bridge.log("MAN: No pending or default wearable, returning")
+            Bridge.log("PAIRFLOW: connect_by_name abort reason=no_wearable")
             return
         }
 
         guard NimoResourceFixture.shared.allowsManager(pendingWearable.isEmpty ? defaultWearable : pendingWearable, name: name) else { return }
         if pendingWearable.isEmpty, !defaultWearable.isEmpty {
-            Bridge.log("MAN: No pending wearable, using default wearable: \(defaultWearable)")
+            Bridge.log("PAIRFLOW: connect_by_name pending=\(defaultWearable)")
             pendingWearable = defaultWearable
         }
 
@@ -1927,6 +1981,21 @@ struct ViewState {
             return
         }
 
+        // Only an existing Mentra Live manager is reused. Calling initSGC first would swap out a
+        // manager of another model here, before the queued handoff below disposes of it.
+        if pendingWearable.contains(DeviceTypes.LIVE), let live = sgc as? MentraLive, !live.isManagerKilled {
+            // The pairing scan already found this peripheral. Destroying the
+            // manager here drops it, and the glasses are no longer discoverable
+            // after the BLE bond, so the replacement scan never sees them.
+            Bridge.log("PAIRFLOW: connect_by_name decision=reuse_manager name=\(name)")
+            searching = true
+            pendingDeviceName = name
+            live.setRequiresAncs(requiresAncs)
+            live.connectById(name)
+            return
+        }
+
+        Bridge.log("PAIRFLOW: connect_by_name decision=new_manager name=\(name)")
         let managerEntry = NimoResourceFixture.shared.beginManagerEntry(pendingWearable)
         Task {
             defer { NimoResourceFixture.shared.endManagerEntry(managerEntry) }
@@ -1972,6 +2041,8 @@ struct ViewState {
         #if os(macOS)
         audioRouteObserver = nil
         glassesBluetoothClassicConnected = false
+        glassesBluetoothClassicProfilesConnected = false
+        glassesBluetoothAudioRouted = false
         otherBtConnected = false
         #endif
         sgc?.clearDisplay() // clear the screen
@@ -2048,6 +2119,9 @@ struct ViewState {
 
     func forget() {
         Bridge.log("MAN: Forgetting smart glasses")
+        MentraLivePairingStateStore.shared.update("forget") { $0.onForget() }
+        clearOwnerLost()
+        clearSecureFirmware()
         // Call forget first to stop timers/handlers/reconnect logic
         sgc?.forget()
         disconnect()

package/ios/Source/DeviceStore.swift

@@ -31,6 +31,8 @@ class DeviceStore {
         store.set("glasses", "micEnabled", false)
         store.set("glasses", "voiceActivityDetectionEnabled", BluetoothSdkDefaults.voiceActivityDetectionEnabled)
         store.set("glasses", "bluetoothClassicConnected", false)
+        store.set("glasses", "bluetoothClassicProfilesConnected", false)
+        store.set("glasses", "bluetoothAudioRouted", false)
         store.set("glasses", "caseRemoved", true)
         store.set("glasses", "caseOpen", true)
         store.set("glasses", "caseCharging", false)
@@ -59,6 +61,7 @@ class DeviceStore {
         store.set("glasses", "signalStrength", -1)
         store.set("glasses", "signalStrengthUpdatedAt", 0)
         store.set("glasses", "ringSignalStrength", -1)
+        store.set("glasses", "audioSetup", GlassesAudioSetupState.idle.toMap())
 
         // CORE STATE:
         store.set("bluetooth", "systemMicUnavailable", false)
@@ -144,10 +147,34 @@ class DeviceStore {
         }
     }
 
+    /// Publishes `GlassesStatus.audioSetup` and `audio_setup_changed` when the state changed.
+    @discardableResult
+    func publishAudioSetup(_ state: GlassesAudioSetupState) -> Bool {
+        guard GlassesAudioSetupState(map: store.get("glasses", "audioSetup")) != state else { return false }
+        let map = state.toMap()
+        store.set("glasses", "audioSetup", map)
+        Bridge.sendTypedMessage("audio_setup_changed", body: ["state": map])
+        return true
+    }
+
+    /// Glasses without a driver-specific audio rule report `not_applicable` while ready and
+    /// `idle` otherwise. Runs before readiness is stored, so the update that marks the glasses
+    /// ready already carries the matching `audioSetup`.
+    private func publishModelDefaultAudioSetup(_ category: String, _ key: String, _ value: Any) {
+        guard ObservableStore.normalizeCategory(category) == "glasses", key == "fullyBooted",
+              let ready = value as? Bool,
+              DeviceManager.shared.sgc?.publishesAudioSetup != true
+        else { return }
+        publishAudioSetup(.modelDefault(ready: ready))
+    }
+
     /// Apply changes with side effects
     func apply(_ category: String, _ key: String, _ value: Any) {
         let oldValue = store.get(category, key)
         let storeWouldSkipSet = store.wouldSkipSet(category, key, value)
+        if !storeWouldSkipSet {
+            publishModelDefaultAudioSetup(category, key, value)
+        }
         store.set(category, key, value)
         if storeWouldSkipSet {
             return

package/ios/Source/GeneratedReleaseMetadata.swift

@@ -3,9 +3,9 @@ import Foundation
 /// Generated by release CI. Do not edit in a release checkout.
 enum GeneratedReleaseMetadata {
     static let familyBaseVersion = "3.4.0"
-    static let releaseIdentity = "3.4.0-dev.993"
-    static let releaseSetId = "mentra-3.4.0-dev.993"
-    static let sourceCommit = "7fd0a5cfd9fb3db878f18f3975121c613a4b8fcc"
-    static let otaManifestUrl = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.4.0/mentra-live-ota-3.4.0-dev.993.json"
-    static let otaManifestSha256 = "fb9e951467dcb09ceca5e7b3c244f6e7c21f0fd61efadbf3c06d59134e272345"
+    static let releaseIdentity = "3.4.0-dev.998"
+    static let releaseSetId = "mentra-3.4.0-dev.998"
+    static let sourceCommit = "c77108af50fcaabe3f2c1464b2a5d649a30e337b"
+    static let otaManifestUrl = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.4.0/mentra-live-ota-3.4.0-dev.998.json"
+    static let otaManifestSha256 = "8c797478019499beb9a637bf418ff6586fd974115f712dfb51c7a96f6e08151c"
 }

package/ios/Source/MentraBluetoothSDK.swift

@@ -549,6 +549,7 @@ public final class MentraBluetoothSDK {
         let isController = ControllerTypes.ALL.contains(device.model.deviceType)
         if !isController {
             requiresAncsForBluetoothRestore = options.requiresAncs
+            MentraLive.enableTransportBridging = options.enableTransportBridging
         }
         if options.cancelExistingConnectionAttempt {
             if isController {
@@ -557,6 +558,9 @@ public final class MentraBluetoothSDK {
                 cancelConnectionAttempt()
             }
         }
+        if !isController {
+            MentraLive.clearStaleIosBondPrompt()
+        }
         if options.saveAsDefault && !isController {
             setDefaultDevice(device)
         } else if !isController {
@@ -575,6 +579,7 @@ public final class MentraBluetoothSDK {
     public func connectDefault(options: ConnectOptions = ConnectOptions()) throws {
         clearBluetoothRestoreIntent()
         requiresAncsForBluetoothRestore = options.requiresAncs
+        MentraLive.enableTransportBridging = options.enableTransportBridging
         guard let device = currentDefaultDevice() else {
             throw BluetoothSdkError(
                 code: "default_device_missing",
@@ -2722,9 +2727,9 @@ public final class MentraBluetoothSDK {
             let event = GalleryStatusEvent(values: data)
             pendingGalleryStatus?.resolve(event)
             delegate?.mentraBluetoothSDK(self, didReceive: .raw(name: "gallery_status", values: event.values))
-        case "pairing_info":
-            delegate?.mentraBluetoothSDK(self, didReceive: .raw(name: "pairing_info", values: data))
-        case "entering_pairing_mode", "owner_replaced":
+        case "pairing_info", "pairing_state_changed", "audio_setup_changed":
+            delegate?.mentraBluetoothSDK(self, didReceive: .raw(name: eventName, values: data))
+        case "entering_pairing_mode", "pairing_mode_ended", "owner_replaced":
             delegate?.mentraBluetoothSDK(self, didReceive: .raw(name: eventName, values: data))
         case "photo_response":
             let event = PhotoResponseEvent(values: data)
@@ -2820,7 +2825,8 @@ public final class MentraBluetoothSDK {
                 self,
                 didFail: BluetoothSdkError(
                     code: "pair_failure",
-                    message: data["error"] as? String ?? data.description
+                    message: data["error"] as? String ?? data.description,
+                    failureCode: data["code"] as? String
                 )
             )
         default:

package/ios/Source/errors/BluetoothSdkError.swift

@@ -3,10 +3,14 @@ import Foundation
 public struct BluetoothSdkError: Error, LocalizedError, CustomStringConvertible {
     public let code: String
     public let message: String
+    /// Machine-readable reason a `pair_failure` carries (`pair_failure.code`), such as
+    /// `ios_forget_pairing`. Nil for other errors.
+    public let failureCode: String?
 
-    public init(code: String, message: String) {
+    public init(code: String, message: String, failureCode: String? = nil) {
         self.code = code
         self.message = message
+        self.failureCode = failureCode
     }
 
     public var errorDescription: String? {

package/ios/Source/sgcs/GlassesAudioSetupPolicy.swift

@@ -0,0 +1,181 @@
+import Foundation
+
+/// Whether the user has to do anything to get glasses audio working (`GlassesAudioSetupState` in
+/// BluetoothSdk.types.ts). Published as `GlassesStatus.audioSetup` and `audio_setup_changed`.
+/// Same map encoding as Android `GlassesAudioSetupState`.
+enum GlassesAudioSetupState: Equatable {
+    /// No glasses session.
+    case idle
+    /// This platform and glasses need no user step for audio.
+    case notApplicable
+    /// The link is up, audio is not, and the SDK still expects audio to come up on its own.
+    case connecting
+    /// Classic audio to these glasses is up.
+    case connected
+    /// Audio did not come up on its own. The user connects it in system Bluetooth settings.
+    case needsUser(action: String)
+
+    static let connectInSettingsAction = "connect_in_settings"
+    static let needsUserConnectInSettings = GlassesAudioSetupState.needsUser(action: connectInSettingsAction)
+
+    var name: String {
+        switch self {
+        case .idle: return "idle"
+        case .notApplicable: return "not_applicable"
+        case .connecting: return "connecting"
+        case .connected: return "connected"
+        case .needsUser: return "needs_user"
+        }
+    }
+
+    /// Native map encoding: `{"state": "needs_user", "action": "connect_in_settings"}`.
+    func toMap() -> [String: Any] {
+        if case let .needsUser(action) = self {
+            return ["state": name, "action": action]
+        }
+        return ["state": name]
+    }
+
+    init?(map: Any?) {
+        guard let map = map as? [String: Any], let state = map["state"] as? String else { return nil }
+        switch state {
+        case "idle": self = .idle
+        case "not_applicable": self = .notApplicable
+        case "connecting": self = .connecting
+        case "connected": self = .connected
+        case "needs_user":
+            self = .needsUser(action: map["action"] as? String ?? Self.connectInSettingsAction)
+        default: return nil
+        }
+    }
+
+    /// Glasses without a driver-specific rule (every model except Mentra Live today): no user
+    /// step while the glasses are ready.
+    static func modelDefault(ready: Bool) -> GlassesAudioSetupState {
+        ready ? .notApplicable : .idle
+    }
+}
+
+/// When the SDK started waiting for audio. Recorded when the session becomes ready.
+enum GlassesAudioSetupPhase: Equatable {
+    /// Readiness completed an explicit pairing attempt. `autoAudio` is this session's
+    /// `pairing_info.auto_audio`; old firmware never sends it.
+    case pairing(autoAudio: Bool)
+    /// Any other readiness, and audio lost after `connected`.
+    case reconnect
+
+    var logName: String {
+        switch self {
+        case let .pairing(autoAudio): return autoAudio ? "pairing_auto_audio" : "pairing"
+        case .reconnect: return "reconnect"
+        }
+    }
+}
+
+struct GlassesAudioSetupInputs: Equatable {
+    var sessionReady: Bool
+    /// A `classic_link` report arrived in this BLE session.
+    var glassesReportsClassicLink: Bool
+    var glassesA2dp: Bool
+    var glassesHfp: Bool
+    /// The phone's own signals: Classic bond, a connected HFP input or a matching Bluetooth output.
+    var phoneAudioUp: Bool
+    var phase: GlassesAudioSetupPhase
+    var phaseStartedAtMs: Int
+}
+
+struct GlassesAudioSetupDecision: Equatable {
+    let state: GlassesAudioSetupState
+    /// When the state changes on its own if no input changes first. Nil when it never does.
+    let nextDeadlineMs: Int?
+}
+
+/// iOS audio-setup rules for glasses that bring Classic audio up from the BLE pair. Pure: the
+/// driver feeds inputs and arms one timer for `nextDeadlineMs`. Android has no user step and
+/// reports `not_applicable` while ready.
+enum GlassesAudioSetupPolicy {
+    static let pairingAutoAudioWaitMs = 8000
+    static let reconnectAudioGraceMs = 10000
+
+    /// Either source is enough. A glasses report of both links down never vetoes the phone's view.
+    static func audioUp(_ inputs: GlassesAudioSetupInputs) -> Bool {
+        (inputs.glassesReportsClassicLink && (inputs.glassesA2dp || inputs.glassesHfp)) || inputs.phoneAudioUp
+    }
+
+    static func waitMs(_ phase: GlassesAudioSetupPhase) -> Int {
+        switch phase {
+        case let .pairing(autoAudio): return autoAudio ? pairingAutoAudioWaitMs : 0
+        case .reconnect: return reconnectAudioGraceMs
+        }
+    }
+
+    static func decide(_ inputs: GlassesAudioSetupInputs, nowMs: Int) -> GlassesAudioSetupDecision {
+        guard inputs.sessionReady else { return GlassesAudioSetupDecision(state: .idle, nextDeadlineMs: nil) }
+        if audioUp(inputs) { return GlassesAudioSetupDecision(state: .connected, nextDeadlineMs: nil) }
+        // A report of A2DP and HFP both down does not shorten the wait: iOS may still be
+        // bringing the link up.
+        let deadline = inputs.phaseStartedAtMs + waitMs(inputs.phase)
+        if nowMs < deadline {
+            return GlassesAudioSetupDecision(state: .connecting, nextDeadlineMs: deadline)
+        }
+        return GlassesAudioSetupDecision(state: .needsUserConnectInSettings, nextDeadlineMs: nil)
+    }
+}
+
+/// Per-driver audio-setup bookkeeping around `GlassesAudioSetupPolicy`: the phase, the glasses'
+/// `classic_link` report for the current BLE session, and the last published state.
+struct GlassesAudioSetupTracker {
+    private(set) var phase: GlassesAudioSetupPhase = .reconnect
+    private(set) var phaseStartedAtMs = 0
+    private(set) var glassesReportsClassicLink = false
+    private(set) var glassesA2dp = false
+    private(set) var glassesHfp = false
+    private(set) var state: GlassesAudioSetupState = .idle
+
+    /// The session became ready.
+    mutating func startPhase(_ phase: GlassesAudioSetupPhase, nowMs: Int) {
+        self.phase = phase
+        phaseStartedAtMs = nowMs
+    }
+
+    mutating func classicLink(a2dp: Bool, hfp: Bool) {
+        glassesReportsClassicLink = true
+        glassesA2dp = a2dp
+        glassesHfp = hfp
+    }
+
+    /// The BLE session ended. The next session has not reported its Classic link yet.
+    mutating func endSession() {
+        glassesReportsClassicLink = false
+        glassesA2dp = false
+        glassesHfp = false
+    }
+
+    func inputs(sessionReady: Bool, phoneAudioUp: Bool) -> GlassesAudioSetupInputs {
+        GlassesAudioSetupInputs(
+            sessionReady: sessionReady,
+            glassesReportsClassicLink: glassesReportsClassicLink,
+            glassesA2dp: glassesA2dp,
+            glassesHfp: glassesHfp,
+            phoneAudioUp: phoneAudioUp,
+            phase: phase,
+            phaseStartedAtMs: phaseStartedAtMs
+        )
+    }
+
+    /// Re-evaluates and records the new state. Losing audio after `connected` starts the
+    /// reconnect wait again from `nowMs`.
+    mutating func evaluate(sessionReady: Bool, phoneAudioUp: Bool, nowMs: Int) -> GlassesAudioSetupDecision {
+        var decision = GlassesAudioSetupPolicy.decide(
+            inputs(sessionReady: sessionReady, phoneAudioUp: phoneAudioUp), nowMs: nowMs
+        )
+        if state == .connected, sessionReady, decision.state != .connected {
+            startPhase(.reconnect, nowMs: nowMs)
+            decision = GlassesAudioSetupPolicy.decide(
+                inputs(sessionReady: sessionReady, phoneAudioUp: phoneAudioUp), nowMs: nowMs
+            )
+        }
+        state = decision.state
+        return decision
+    }
+}