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

package/ios/Tests/GlassesAudioSetupPolicyTests.swift

@@ -0,0 +1,191 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+/// Table tests for the iOS audio-setup rules (Android reports `not_applicable` while ready).
+final class GlassesAudioSetupPolicyTests: XCTestCase {
+    private typealias Policy = GlassesAudioSetupPolicy
+    private let t0 = 1_000_000
+
+    private func inputs(
+        ready: Bool = true,
+        report: (a2dp: Bool, hfp: Bool)? = nil,
+        phone: Bool = false,
+        phase: GlassesAudioSetupPhase = .reconnect,
+        startedAt: Int? = nil
+    ) -> GlassesAudioSetupInputs {
+        GlassesAudioSetupInputs(
+            sessionReady: ready,
+            glassesReportsClassicLink: report != nil,
+            glassesA2dp: report?.a2dp ?? false,
+            glassesHfp: report?.hfp ?? false,
+            phoneAudioUp: phone,
+            phase: phase,
+            phaseStartedAtMs: startedAt ?? t0
+        )
+    }
+
+    private func state(_ inputs: GlassesAudioSetupInputs, at offsetMs: Int) -> GlassesAudioSetupState {
+        Policy.decide(inputs, nowMs: t0 + offsetMs).state
+    }
+
+    func testConstantsMatchTheContract() {
+        XCTAssertEqual(Policy.pairingAutoAudioWaitMs, 8000)
+        XCTAssertEqual(Policy.reconnectAudioGraceMs, 10000)
+    }
+
+    func testNoSessionIsIdle() {
+        XCTAssertEqual(
+            Policy.decide(inputs(ready: false, report: (true, true), phone: true), nowMs: t0),
+            GlassesAudioSetupDecision(state: .idle, nextDeadlineMs: nil)
+        )
+    }
+
+    func testPairingWithAutoAudioWaitsEightSecondsThenNeedsTheUser() {
+        let pairing = inputs(phase: .pairing(autoAudio: true))
+        XCTAssertEqual(
+            Policy.decide(pairing, nowMs: t0),
+            GlassesAudioSetupDecision(state: .connecting, nextDeadlineMs: t0 + 8000)
+        )
+        XCTAssertEqual(state(pairing, at: 7999), .connecting)
+        XCTAssertEqual(state(pairing, at: 8000), .needsUserConnectInSettings)
+    }
+
+    func testPairingWithoutAutoAudioNeedsTheUserAtOnce() {
+        XCTAssertEqual(
+            Policy.decide(inputs(phase: .pairing(autoAudio: false)), nowMs: t0),
+            GlassesAudioSetupDecision(state: .needsUserConnectInSettings, nextDeadlineMs: nil)
+        )
+    }
+
+    func testReconnectWaitsTenSecondsThenNeedsTheUser() {
+        let reconnect = inputs(phase: .reconnect)
+        XCTAssertEqual(
+            Policy.decide(reconnect, nowMs: t0 + 1000),
+            GlassesAudioSetupDecision(state: .connecting, nextDeadlineMs: t0 + 10000)
+        )
+        XCTAssertEqual(state(reconnect, at: 9999), .connecting)
+        XCTAssertEqual(state(reconnect, at: 10000), .needsUserConnectInSettings)
+    }
+
+    func testEitherAudioSourceIsEnoughInEveryPhase() {
+        for phase in [GlassesAudioSetupPhase.pairing(autoAudio: true), .pairing(autoAudio: false), .reconnect] {
+            for offset in [0, 30000] {
+                XCTAssertEqual(state(inputs(phone: true, phase: phase), at: offset), .connected, "phone \(phase)")
+                XCTAssertEqual(state(inputs(report: (true, false), phase: phase), at: offset), .connected, "a2dp \(phase)")
+                XCTAssertEqual(state(inputs(report: (false, true), phase: phase), at: offset), .connected, "hfp \(phase)")
+            }
+        }
+        XCTAssertEqual(Policy.decide(inputs(phone: true), nowMs: t0).nextDeadlineMs, nil)
+    }
+
+    func testAGlassesReportOfBothLinksDownNeverShortensTheWait() {
+        let down = inputs(report: (false, false), phase: .pairing(autoAudio: true))
+        XCTAssertEqual(state(down, at: 1), .connecting)
+        XCTAssertEqual(Policy.decide(down, nowMs: t0 + 1).nextDeadlineMs, t0 + 8000)
+        XCTAssertEqual(state(inputs(report: (false, false), phase: .reconnect), at: 9000), .connecting)
+    }
+
+    func testABothDownReportDoesNotVetoThePhone() {
+        XCTAssertEqual(state(inputs(report: (false, false), phone: true), at: 0), .connected)
+    }
+
+    func testTheGlassesReportArrivingBeforeThePhoneSignals() {
+        var tracker = GlassesAudioSetupTracker()
+        tracker.startPhase(.pairing(autoAudio: true), nowMs: t0)
+        tracker.classicLink(a2dp: true, hfp: true)
+        XCTAssertEqual(tracker.evaluate(sessionReady: true, phoneAudioUp: false, nowMs: t0 + 100).state, .connected)
+        // The phone's route catches up later: still connected, nothing to re-arm.
+        XCTAssertEqual(
+            tracker.evaluate(sessionReady: true, phoneAudioUp: true, nowMs: t0 + 900),
+            GlassesAudioSetupDecision(state: .connected, nextDeadlineMs: nil)
+        )
+    }
+
+    func testTheGlassesReportArrivingAfterThePhoneSignals() {
+        var tracker = GlassesAudioSetupTracker()
+        tracker.startPhase(.reconnect, nowMs: t0)
+        XCTAssertEqual(tracker.evaluate(sessionReady: true, phoneAudioUp: true, nowMs: t0 + 100).state, .connected)
+        // The glasses then report both down (for example A2DP closing while HFP reconnects).
+        // The phone still sees audio, so the state stays connected.
+        tracker.classicLink(a2dp: false, hfp: false)
+        XCTAssertEqual(tracker.evaluate(sessionReady: true, phoneAudioUp: true, nowMs: t0 + 200).state, .connected)
+    }
+
+    func testAReportAfterNeedsUserMovesToConnected() {
+        var tracker = GlassesAudioSetupTracker()
+        tracker.startPhase(.pairing(autoAudio: false), nowMs: t0)
+        XCTAssertEqual(tracker.evaluate(sessionReady: true, phoneAudioUp: false, nowMs: t0).state, .needsUserConnectInSettings)
+        tracker.classicLink(a2dp: false, hfp: true)
+        XCTAssertEqual(tracker.evaluate(sessionReady: true, phoneAudioUp: false, nowMs: t0 + 60000).state, .connected)
+    }
+
+    func testLosingAudioAfterConnectedStartsTheReconnectWaitAgain() {
+        var tracker = GlassesAudioSetupTracker()
+        tracker.startPhase(.pairing(autoAudio: false), nowMs: t0)
+        XCTAssertEqual(tracker.evaluate(sessionReady: true, phoneAudioUp: true, nowMs: t0 + 500).state, .connected)
+
+        let lostAt = t0 + 60000
+        XCTAssertEqual(
+            tracker.evaluate(sessionReady: true, phoneAudioUp: false, nowMs: lostAt),
+            GlassesAudioSetupDecision(state: .connecting, nextDeadlineMs: lostAt + 10000)
+        )
+        XCTAssertEqual(tracker.phase, .reconnect)
+        XCTAssertEqual(tracker.phaseStartedAtMs, lostAt)
+        XCTAssertEqual(tracker.evaluate(sessionReady: true, phoneAudioUp: false, nowMs: lostAt + 9999).state, .connecting)
+        XCTAssertEqual(
+            tracker.evaluate(sessionReady: true, phoneAudioUp: false, nowMs: lostAt + 10000).state,
+            .needsUserConnectInSettings
+        )
+    }
+
+    func testTheGlassesReportingAudioDownAfterConnectedStartsTheReconnectWait() {
+        var tracker = GlassesAudioSetupTracker()
+        tracker.startPhase(.reconnect, nowMs: t0)
+        tracker.classicLink(a2dp: true, hfp: true)
+        XCTAssertEqual(tracker.evaluate(sessionReady: true, phoneAudioUp: false, nowMs: t0).state, .connected)
+        tracker.classicLink(a2dp: false, hfp: false)
+        XCTAssertEqual(
+            tracker.evaluate(sessionReady: true, phoneAudioUp: false, nowMs: t0 + 30000),
+            GlassesAudioSetupDecision(state: .connecting, nextDeadlineMs: t0 + 40000)
+        )
+    }
+
+    func testASessionDropIsIdleAndForgetsTheGlassesReport() {
+        var tracker = GlassesAudioSetupTracker()
+        tracker.startPhase(.reconnect, nowMs: t0)
+        tracker.classicLink(a2dp: true, hfp: false)
+        XCTAssertEqual(tracker.evaluate(sessionReady: true, phoneAudioUp: false, nowMs: t0).state, .connected)
+
+        tracker.endSession()
+        XCTAssertEqual(
+            tracker.evaluate(sessionReady: false, phoneAudioUp: false, nowMs: t0 + 1000),
+            GlassesAudioSetupDecision(state: .idle, nextDeadlineMs: nil)
+        )
+        XCTAssertFalse(tracker.glassesReportsClassicLink)
+
+        // The next session has not reported its link yet.
+        tracker.startPhase(.reconnect, nowMs: t0 + 2000)
+        XCTAssertEqual(tracker.evaluate(sessionReady: true, phoneAudioUp: false, nowMs: t0 + 2000).state, .connecting)
+    }
+
+    func testMapEncodingMatchesTheContract() {
+        XCTAssertEqual(GlassesAudioSetupState.idle.toMap() as NSDictionary, ["state": "idle"])
+        XCTAssertEqual(GlassesAudioSetupState.notApplicable.toMap() as NSDictionary, ["state": "not_applicable"])
+        XCTAssertEqual(GlassesAudioSetupState.connecting.toMap() as NSDictionary, ["state": "connecting"])
+        XCTAssertEqual(GlassesAudioSetupState.connected.toMap() as NSDictionary, ["state": "connected"])
+        XCTAssertEqual(
+            GlassesAudioSetupState.needsUserConnectInSettings.toMap() as NSDictionary,
+            ["state": "needs_user", "action": "connect_in_settings"]
+        )
+        for state in [GlassesAudioSetupState.idle, .notApplicable, .connecting, .connected, .needsUserConnectInSettings] {
+            XCTAssertEqual(GlassesAudioSetupState(map: state.toMap()), state)
+        }
+        XCTAssertNil(GlassesAudioSetupState(map: ["state": "unknown"]))
+        XCTAssertNil(GlassesAudioSetupState(map: nil))
+    }
+
+    func testModelsWithoutADriverRuleAreNotApplicableWhileReady() {
+        XCTAssertEqual(GlassesAudioSetupState.modelDefault(ready: true), .notApplicable)
+        XCTAssertEqual(GlassesAudioSetupState.modelDefault(ready: false), .idle)
+    }
+}

package/ios/Tests/MentraLiveAudioSetupTests.swift

@@ -0,0 +1,215 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+@MainActor
+private final class AudioSetupTransport: MentraLive {
+    var commands: [[String: Any]] = []
+
+    override func sendJson(_ jsonOriginal: [String: Any], wakeUp _: Bool, requireAck _: Bool) {
+        commands.append(jsonOriginal)
+    }
+}
+
+/// `GlassesStatus.audioSetup` wiring: the Mentra Live driver on iOS and the shared default for
+/// every other model.
+@MainActor
+final class MentraLiveAudioSetupTests: XCTestCase {
+    private let phoneAudioKeys = ["bluetoothClassicConnected", "bluetoothClassicProfilesConnected", "bluetoothAudioRouted"]
+
+    private func withTransport(
+        _ body: (AudioSetupTransport, ObservableStore, _ clock: (Int) -> Void) throws -> Void
+    ) rethrows {
+        let store = DeviceStore.shared.store
+        let saved = ["bluetooth", "glasses"].map { ($0, store.getCategory($0)) }
+        let previous = DeviceManager.shared.sgc
+        UserDefaults.standard.removeObject(forKey: MentraLivePairingStateStore.defaultsKey)
+        MentraLivePairingStateStore.shared.resetForTest()
+        store.set("glasses", "fullyBooted", false)
+        for key in phoneAudioKeys {
+            store.set("glasses", key, false)
+        }
+        store.set("bluetooth", "pending_device_name", "")
+        store.set("bluetooth", "pending_device_address", "")
+        store.set("bluetooth", "pending_device_secure_pairing_capable", "")
+        store.set("glasses", "audioSetup", GlassesAudioSetupState.idle.toMap())
+        let transport = AudioSetupTransport()
+        DeviceManager.shared.sgc = transport
+        var nowMs = 1_000_000
+        transport.audioSetupNowMs = { nowMs }
+        defer {
+            transport.cleanup()
+            DeviceManager.shared.sgc = previous
+            UserDefaults.standard.removeObject(forKey: MentraLivePairingStateStore.defaultsKey)
+            MentraLivePairingStateStore.shared.resetForTest()
+            for (category, values) in saved {
+                for key in store.getCategory(category).keys where values[key] == nil {
+                    store.remove(category, key)
+                }
+                for (key, value) in values {
+                    store.set(category, key, value)
+                }
+            }
+        }
+        try body(transport, store) { nowMs = $0 }
+    }
+
+    private func receive(_ transport: MentraLive, _ value: [String: Any]) throws {
+        try transport.processReceivedData(JSONSerialization.data(withJSONObject: value))
+    }
+
+    private func audioSetup(_ store: ObservableStore) -> GlassesAudioSetupState? {
+        GlassesAudioSetupState(map: store.get("glasses", "audioSetup"))
+    }
+
+    /// The audioSetup visible at the moment `fullyBooted` flips to true.
+    private func audioSetupWhenReady(_ store: ObservableStore, _ action: () throws -> Void) rethrows -> GlassesAudioSetupState? {
+        var seen: GlassesAudioSetupState?
+        let listener = store.addListener { category, changes in
+            guard category == "glasses", changes["fullyBooted"] as? Bool == true else { return }
+            seen = GlassesAudioSetupState(map: store.get("glasses", "audioSetup"))
+        }
+        defer { store.removeListener(listener) }
+        try action()
+        return seen
+    }
+
+    func testAReconnectReportsConnectingWithReadinessThenFollowsTheGlassesReport() throws {
+        try withTransport { transport, store, clock in
+            var events: [[String: Any]] = []
+            let sink = Bridge.addEventSink { event, body in
+                if event == "audio_setup_changed", let state = body["state"] as? [String: Any] { events.append(state) }
+            }
+            defer { Bridge.removeEventSink(sink) }
+
+            clock(1_000_000)
+            let atReady = try audioSetupWhenReady(store) {
+                try receive(transport, ["type": "glasses_ready", "sid": "reconnect"])
+            }
+            XCTAssertEqual(atReady, .connecting, "the ready update never carries a stale idle")
+            XCTAssertEqual(events.last as NSDictionary?, ["state": "connecting"])
+
+            clock(1_002_000)
+            try receive(transport, ["type": "classic_link", "a2dp": true, "hfp": false])
+            XCTAssertEqual(audioSetup(store), .connected)
+            XCTAssertEqual(events.last as NSDictionary?, ["state": "connected"])
+            let eventCount = events.count
+
+            // The same report again is not a change.
+            try receive(transport, ["type": "classic_link", "a2dp": true, "hfp": false])
+            XCTAssertEqual(events.count, eventCount)
+
+            // Audio lost after connected: the reconnect wait starts again from now.
+            clock(1_060_000)
+            try receive(transport, ["type": "classic_link", "a2dp": false, "hfp": false])
+            XCTAssertEqual(audioSetup(store), .connecting)
+            clock(1_069_999)
+            try receive(transport, ["type": "classic_link", "a2dp": false, "hfp": false])
+            XCTAssertEqual(audioSetup(store), .connecting)
+
+            // The deadline timer gives up at the end of the wait.
+            clock(1_069_950)
+            try receive(transport, ["type": "classic_link", "a2dp": false, "hfp": false])
+            clock(1_070_000)
+            let deadline = Date().addingTimeInterval(2)
+            while audioSetup(store) != .needsUserConnectInSettings, Date() < deadline {
+                RunLoop.main.run(until: Date().addingTimeInterval(0.01))
+            }
+            XCTAssertEqual(audioSetup(store), .needsUserConnectInSettings)
+            XCTAssertEqual(events.last as NSDictionary?, ["state": "needs_user", "action": "connect_in_settings"])
+
+            // The phone's own signals are enough on their own.
+            store.set("glasses", "bluetoothAudioRouted", true)
+            XCTAssertEqual(audioSetup(store), .connected)
+
+            // Session drop.
+            transport.cleanup()
+            XCTAssertEqual(audioSetup(store), .idle)
+            XCTAssertEqual(events.last as NSDictionary?, ["state": "idle"])
+        }
+    }
+
+    func testAnExplicitPairOnOldFirmwareNeedsTheUserInTheReadyUpdate() throws {
+        try withTransport { transport, store, _ in
+            store.set("bluetooth", "pending_device_name", "MENTRA_LIVE_BLE_ABCD")
+            store.set("bluetooth", "pending_device_secure_pairing_capable", false)
+            let atReady = try audioSetupWhenReady(store) {
+                try receive(transport, ["type": "glasses_ready", "sid": "legacy"])
+            }
+            XCTAssertEqual(atReady, .needsUserConnectInSettings)
+            XCTAssertEqual(audioSetup(store), .needsUserConnectInSettings)
+
+            store.set("glasses", "bluetoothClassicConnected", true)
+            XCTAssertEqual(audioSetup(store), .connected)
+        }
+    }
+
+    func testAnExplicitSecurePairWithAutoAudioWaitsForAudio() throws {
+        try withTransport { transport, store, clock in
+            store.set("bluetooth", "pending_device_name", "MENTRA_LIVE_BLE_ABCD")
+            store.set("bluetooth", "pending_device_secure_pairing_capable", true)
+            clock(2_000_000)
+            try receive(transport, ["type": "glasses_ready", "sid": "secure"])
+            XCTAssertEqual(audioSetup(store), .idle, "not ready before the owner commit")
+            let atReady = try audioSetupWhenReady(store) {
+                try receive(transport, [
+                    "type": "pairing_info", "secure_pairing_capable": true, "owner_committed": true,
+                    "auto_audio": true, "protocol_version": 4,
+                ])
+            }
+            XCTAssertEqual(atReady, .connecting)
+            // A both-down report does not shorten the 8 s wait.
+            clock(2_001_000)
+            try receive(transport, ["type": "classic_link", "a2dp": false, "hfp": false])
+            XCTAssertEqual(audioSetup(store), .connecting)
+            clock(2_008_000)
+            try receive(transport, ["type": "classic_link", "a2dp": false, "hfp": false])
+            XCTAssertEqual(audioSetup(store), .needsUserConnectInSettings)
+        }
+    }
+
+    func testReadinessLostIsIdle() throws {
+        try withTransport { transport, store, _ in
+            try receive(transport, ["type": "glasses_ready", "sid": "first"])
+            XCTAssertEqual(audioSetup(store), .connecting)
+            // sr_hrt ready=0 and ASG restarts clear readiness on a live link.
+            DeviceStore.shared.set("glasses", "fullyBooted", false)
+            XCTAssertEqual(audioSetup(store), .idle)
+        }
+    }
+
+    func testModelsWithoutADriverRuleAreNotApplicableInTheReadyUpdate() {
+        let store = DeviceStore.shared.store
+        let saved = store.getCategory("glasses")
+        let previous = DeviceManager.shared.sgc
+        DeviceManager.shared.sgc = nil
+        defer {
+            DeviceManager.shared.sgc = previous
+            for key in store.getCategory("glasses").keys where saved[key] == nil {
+                store.remove("glasses", key)
+            }
+            for (key, value) in saved {
+                store.set("glasses", key, value)
+            }
+        }
+        store.set("glasses", "fullyBooted", false)
+        store.set("glasses", "audioSetup", GlassesAudioSetupState.idle.toMap())
+        var events: [[String: Any]] = []
+        let sink = Bridge.addEventSink { event, body in
+            if event == "audio_setup_changed", let state = body["state"] as? [String: Any] { events.append(state) }
+        }
+        defer { Bridge.removeEventSink(sink) }
+
+        let atReady = audioSetupWhenReady(store) {
+            DeviceStore.shared.apply("glasses", "fullyBooted", true)
+        }
+        XCTAssertEqual(atReady, .notApplicable)
+        XCTAssertEqual(events as [NSDictionary], [["state": "not_applicable"]])
+        let snapshot = GlassesStatus(values: store.getCategory("glasses"))
+        XCTAssertEqual(snapshot.audioSetup as NSDictionary?, ["state": "not_applicable"])
+        XCTAssertEqual(snapshot.dictionary["audioSetup"] as? NSDictionary, ["state": "not_applicable"])
+
+        DeviceStore.shared.apply("glasses", "fullyBooted", false)
+        XCTAssertEqual(audioSetup(store), .idle)
+        XCTAssertEqual(events.count, 2)
+    }
+}

package/ios/Tests/MentraLiveConnectionOptionsTests.swift

@@ -11,20 +11,75 @@ final class MentraLiveConnectionOptionsTests: XCTestCase {
         XCTAssertFalse(ConnectOptions(requiresAncs: false).requiresAncs)
     }
 
+    func testConnectOptionsEnableTransportBridgingByDefault() {
+        XCTAssertTrue(ConnectOptions().enableTransportBridging)
+    }
+
+    func testConnectOptionsCanEnableTransportBridging() {
+        XCTAssertTrue(ConnectOptions(enableTransportBridging: true).enableTransportBridging)
+    }
+
     #if os(macOS)
         func testCoreBluetoothOptionsOmitAncsOnMacOS() {
             XCTAssertNil(MentraLiveConnectionOptions.coreBluetoothOptions(requiresAncs: true))
         }
+
+        func testCoreBluetoothOptionsOmitTransportBridgingOnMacOS() {
+            XCTAssertNil(MentraLiveConnectionOptions.coreBluetoothOptions(
+                requiresAncs: true,
+                enableTransportBridging: true
+            ))
+        }
     #else
         func testCoreBluetoothOptionsRequireAncsWhenEnabled() {
             let options = MentraLiveConnectionOptions.coreBluetoothOptions(requiresAncs: true)
 
+            XCTAssertEqual(options?.count, 1)
+            XCTAssertEqual(options?[CBConnectPeripheralOptionRequiresANCS] as? Bool, true)
+            XCTAssertNil(options?[CBConnectPeripheralOptionEnableTransportBridgingKey])
+        }
+
+        func testCoreBluetoothOptionsKeepAncsWhenTransportBridgingIsExplicitlyOff() {
+            let options = MentraLiveConnectionOptions.coreBluetoothOptions(
+                requiresAncs: true,
+                enableTransportBridging: false
+            )
+
             XCTAssertEqual(options?.count, 1)
             XCTAssertEqual(options?[CBConnectPeripheralOptionRequiresANCS] as? Bool, true)
         }
+
+        func testCoreBluetoothOptionsContainBothWhenAncsAndTransportBridgingAreEnabled() {
+            let options = MentraLiveConnectionOptions.coreBluetoothOptions(
+                requiresAncs: true,
+                enableTransportBridging: true
+            )
+
+            XCTAssertEqual(options?.count, 2)
+            XCTAssertEqual(options?[CBConnectPeripheralOptionRequiresANCS] as? Bool, true)
+            XCTAssertEqual(options?[CBConnectPeripheralOptionEnableTransportBridgingKey] as? Bool, true)
+        }
+
+        func testCoreBluetoothOptionsContainOnlyTransportBridgingWhenAncsIsDisabled() {
+            let options = MentraLiveConnectionOptions.coreBluetoothOptions(
+                requiresAncs: false,
+                enableTransportBridging: true
+            )
+
+            XCTAssertEqual(options?.count, 1)
+            XCTAssertEqual(options?[CBConnectPeripheralOptionEnableTransportBridgingKey] as? Bool, true)
+            XCTAssertNil(options?[CBConnectPeripheralOptionRequiresANCS])
+        }
     #endif
 
     func testCoreBluetoothOptionsAreOmittedWhenAncsIsDisabled() {
         XCTAssertNil(MentraLiveConnectionOptions.coreBluetoothOptions(requiresAncs: false))
     }
+
+    func testCoreBluetoothOptionsAreOmittedWhenNeitherOptionIsSet() {
+        XCTAssertNil(MentraLiveConnectionOptions.coreBluetoothOptions(
+            requiresAncs: false,
+            enableTransportBridging: false
+        ))
+    }
 }