@mentra/bluetooth-sdk 3.2.1-dev.314 → 3.2.1

package/ios/Tests/DeviceManagerReconnectTests.swift

@@ -0,0 +1,362 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+@MainActor
+final class DeviceManagerReconnectTests: XCTestCase {
+    private let requests = ["should_send_lc3", "should_send_pcm", "should_send_transcript", "local_stt_fallback_active"]
+
+    func testDelayedReconnectReplayPreservesNimoDepthEndpoints() {
+        for depth in [0, 10] {
+            withRecordingDevice { manager, store in
+                let device = manager.sgc as! ReconnectRecordingDevice
+                device.type = DeviceTypes.NIMO
+                store.set("bluetooth", "dashboard_height", 7)
+                store.set("bluetooth", "dashboard_depth", depth)
+                let replayed = expectation(description: "Delayed NIMO depth \(depth)")
+                replayed.assertForOverFulfill = false
+                device.onPosition = { replayed.fulfill() }
+                manager.handleDeviceReady()
+                XCTAssertTrue(device.positions.isEmpty)
+                wait(for: [replayed], timeout: 3)
+                XCTAssertEqual(device.positions.last?.0, 7)
+                XCTAssertEqual(device.positions.last?.1, depth)
+            }
+        }
+    }
+
+    private func withRecordingDevice(_ body: (DeviceManager, DeviceStore) -> Void) {
+        let manager = DeviceManager.shared
+        let store = DeviceStore.shared
+        let saved = ["bluetooth", "glasses"].map { ($0, store.store.getCategory($0)) }
+        let previousDevice = manager.sgc
+        let previousController = manager.controller
+        let previousClock = manager.micWatchdogNow
+        manager.micWatchdogNow = { 0 }
+        defer {
+            store.set("bluetooth", "micEnabled", false)
+            manager.updateMicState()
+            manager.micWatchdogNow = previousClock
+            manager.sgc = previousDevice
+            manager.controller = previousController
+            for (category, values) in saved {
+                for key in store.store.getCategory(category).keys where values[key] == nil {
+                    store.store.remove(category, key)
+                }
+                for (key, value) in values {
+                    store.set(category, key, value)
+                }
+            }
+        }
+        manager.controller = nil
+        manager.sgc = ReconnectRecordingDevice()
+        for key in requests {
+            store.set("bluetooth", key, false)
+        }
+        store.set("bluetooth", "micEnabled", false)
+        store.set("bluetooth", "micRanking", [MicTypes.GLASSES_CUSTOM])
+        store.set("glasses", "micEnabled", false)
+        store.set("glasses", "fullyBooted", false)
+        body(manager, store)
+    }
+
+    func testReconnectRestoresUnchangedAudioRequests() {
+        for request in requests {
+            withRecordingDevice { manager, store in
+                store.apply("bluetooth", request, true)
+                XCTAssertEqual(store.get("bluetooth", "micEnabled") as? Bool, true)
+                XCTAssertEqual(store.get("glasses", "micEnabled") as? Bool, true)
+                for _ in 0 ..< 3 {
+                    manager.disconnect()
+                    XCTAssertEqual(store.get("bluetooth", request) as? Bool, true)
+                    XCTAssertEqual(store.get("bluetooth", "micEnabled") as? Bool, false)
+                    XCTAssertEqual(store.get("glasses", "micEnabled") as? Bool, false)
+                    let reconnected = ReconnectRecordingDevice()
+                    manager.sgc = reconnected
+
+                    // Replaying the same consumer request is deduplicated. No test
+                    // reset of glasses.micEnabled: production teardown must clear it.
+                    store.apply("bluetooth", request, true)
+                    XCTAssertEqual(store.get("bluetooth", "micEnabled") as? Bool, false)
+                    store.apply("glasses", "fullyBooted", true)
+
+                    XCTAssertEqual(store.get("bluetooth", "micEnabled") as? Bool, true, request)
+                    XCTAssertEqual(reconnected.micChanges, [true], request)
+                    XCTAssertEqual(store.get("bluetooth", "currentMic") as? String, MicTypes.GLASSES_CUSTOM, request)
+                }
+            }
+        }
+    }
+
+    func testLinkDisconnectRetainsIntentForTheSameCommunicator() {
+        withRecordingDevice { manager, store in
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_lc3", true)
+            let original = manager.sgc as! ReconnectRecordingDevice
+            store.apply("glasses", "fullyBooted", false)
+            XCTAssertTrue((manager.sgc as? ReconnectRecordingDevice) === original)
+            XCTAssertEqual(store.get("bluetooth", "should_send_lc3") as? Bool, true)
+            XCTAssertEqual(store.get("glasses", "micEnabled") as? Bool, true)
+        }
+    }
+
+    func testDiscardingCommunicatorInvalidatesMicCache() {
+        withRecordingDevice { manager, store in
+            store.apply("bluetooth", "should_send_lc3", true)
+            manager.initSGC(manager.sgc!.type)
+            XCTAssertEqual(store.get("glasses", "micEnabled") as? Bool, true)
+
+            // An unsupported model exercises disposal without starting real BLE.
+            manager.initSGC("Unavailable test glasses")
+            XCTAssertNil(manager.sgc)
+            XCTAssertEqual(store.get("glasses", "micEnabled") as? Bool, false)
+            XCTAssertEqual(store.get("bluetooth", "should_send_lc3") as? Bool, true)
+        }
+    }
+
+    func testReconnectWithoutAudioRequestsLeavesMicOff() {
+        withRecordingDevice { manager, store in
+            store.set("glasses", "micEnabled", true)
+            manager.disconnect()
+            XCTAssertEqual(store.get("glasses", "micEnabled") as? Bool, false)
+            let reconnected = ReconnectRecordingDevice()
+            manager.sgc = reconnected
+            store.apply("glasses", "fullyBooted", true)
+            XCTAssertEqual(store.get("bluetooth", "micEnabled") as? Bool, false)
+            XCTAssertEqual(store.get("bluetooth", "currentMic") as? String, "")
+            XCTAssertTrue(reconnected.micChanges.isEmpty)
+        }
+    }
+
+    func testWatchdogRetriesWhenFirstPacketNeverArrivesAndLimitsRetries() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            now = 4
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            now = 5
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true])
+            now = 5.1
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true])
+            now = 10
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true, true])
+        }
+    }
+
+    func testDecodedGlassesAudioKeepsWatchdogHealthyAndMissingPacketsAfterwardRetry() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            // This is the decoded-audio entry point used by Nimo and AR99.
+            for tick in 1 ... 10 {
+                now = TimeInterval(tick * 10)
+                manager.handleGlassesPcm(Data([0, 0]))
+                manager.checkAndReinitGlassesMic()
+            }
+            XCTAssertEqual(device.micChanges, [true])
+            now = 104
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            now = 105
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true])
+        }
+    }
+
+    func testLc3GlassesAudioKeepsWatchdogHealthy() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            let lc3 = manager.lc3Converter!.encode(Data(repeating: 0, count: 320), frameSize: 40) as Data
+            XCTAssertEqual(lc3.count, 40)
+            // G2 and Live deliver LC3 through this entry point, not decoded PCM.
+            for tick in 1 ... 10 {
+                now = TimeInterval(tick * 10)
+                manager.handleGlassesMicData(lc3, 40)
+                manager.checkAndReinitGlassesMic()
+            }
+            XCTAssertEqual(device.micChanges, [true])
+        }
+    }
+
+    func testPhonePcmAndEmptyGlassesPcmCannotHideAMissingGlassesStream() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            now = 5
+            manager.handlePcm(Data([0, 0]))
+            manager.handleGlassesPcm(Data())
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true])
+        }
+    }
+
+    func testWatchdogRespectsSuspensionAndGivesResumeAFreshDeadline() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            device.isMicSuspendedForAudio = true
+            now = 100
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            device.isMicSuspendedForAudio = false
+            now = 200
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            now = 205
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true])
+
+            store.apply("bluetooth", "should_send_pcm", false)
+            // A late firmware ACK can leave the shared cache true after demand ends.
+            store.set("glasses", "micEnabled", true)
+            now = 300
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true, false])
+        }
+    }
+
+    func testWatchdogRespectsOwnAppPlaybackAndPhoneRoute() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            let monitor = PhoneAudioMonitor.getInstance()
+            let wasPlaying = monitor.isOwnAppAudioPlaying()
+            defer { monitor.setOwnAppAudioPlaying(wasPlaying) }
+            monitor.setOwnAppAudioPlaying(false)
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            monitor.setOwnAppAudioPlaying(true)
+            now = 100
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            monitor.setOwnAppAudioPlaying(false)
+            store.set("bluetooth", "currentMic", MicTypes.PHONE_INTERNAL)
+            now = 200
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+        }
+    }
+
+    func testWatchdogDeadlineBelongsToTheCurrentConnection() {
+        withRecordingDevice { manager, store in
+            var now: TimeInterval = 0
+            manager.micWatchdogNow = { now }
+            store.apply("glasses", "fullyBooted", true)
+            store.apply("bluetooth", "should_send_pcm", true)
+            let device = manager.sgc as! ReconnectRecordingDevice
+            store.apply("glasses", "fullyBooted", false)
+            now = 100
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            store.apply("glasses", "fullyBooted", true)
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true])
+            now = 105
+            manager.checkAndReinitGlassesMic()
+            XCTAssertEqual(device.micChanges, [true, true])
+        }
+    }
+}
+
+@MainActor
+private final class ReconnectRecordingDevice: SGCManager {
+    var type = "Reconnect test glasses"
+    let hasMic = true
+    let showConnectionConfirmation = false
+    var micChanges: [Bool] = []
+    var positions: [(Int, Int)] = []
+    var onPosition: (() -> Void)?
+    var isMicSuspendedForAudio = false
+
+    func clearSceneElements(_: [String]) async {}
+    func sendTextWall(_: String) async {}
+    func applySceneFrame(_: SceneFrame) async {}
+    func clearDisplay() {}
+
+    func setMicEnabled(_ enabled: Bool) {
+        micChanges.append(enabled)
+        DeviceStore.shared.set("glasses", "micEnabled", enabled)
+    }
+
+    func sortMicRanking(list: [String]) -> [String] {
+        list
+    }
+
+    func sendJson(_: [String: Any], wakeUp _: Bool, requireAck _: Bool) {}
+    func requestPhoto(_: PhotoRequest) {}
+    func startStream(_: [String: Any]) {}
+    func stopStream() {}
+    func sendStreamKeepAlive(_: [String: Any]) {}
+    func startVideoRecording(requestId _: String, save _: Bool, sound _: Bool) {}
+    func stopVideoRecording(requestId _: String) {}
+    func sendButtonPhotoSettings() {}
+    func sendButtonVideoRecordingSettings() {}
+    func sendCameraFovSetting() {}
+    func sendButtonMaxRecordingTime() {}
+    func setBrightness(_: Int, autoMode _: Bool) {}
+    func sendText(_: String) async {}
+    func sendDoubleTextWall(_: String, _: String) async {}
+    func displayBitmap(base64ImageData _: String, x _: Int32?, y _: Int32?, width _: Int32?, height _: Int32?) async -> Bool {
+        false
+    }
+
+    func showDashboard() {}
+    func setDashboardPosition(_ height: Int, _ depth: Int) {
+        positions.append((height, depth))
+        onPosition?()
+    }
+
+    func setHeadUpAngle(_: Int) {}
+    func getBatteryStatus() {}
+    func setSilentMode(_: Bool) {}
+    func exit() {}
+    func sendShutdown() {}
+    func sendReboot() {}
+    func sendRgbLedControl(requestId _: String, packageName _: String?, action _: String, color _: String?, onDurationMs _: Int, offDurationMs _: Int, count _: Int) {}
+    func disconnect() {}
+    func forget() {}
+    func findCompatibleDevices() {}
+    func stopScan() {}
+    func connectById(_: String) {}
+    func getConnectedBluetoothName() -> String? {
+        nil
+    }
+
+    func cleanup() {}
+    func ping() {}
+    func dbg1() {}
+    func dbg2() {}
+    func connectController() {}
+    func disconnectController() {}
+    func requestWifiScan(scanId _: String?) {}
+    func sendWifiCredentials(_: String, _: String) {}
+    func forgetWifiNetwork(_: String) {}
+    func sendHotspotState(_: Bool) {}
+    func sendUserEmailToGlasses(_: String) {}
+    func sendOtaStart(otaVersionUrl _: String?) {}
+    func sendOtaQueryStatus() {}
+    func queryGalleryStatus() {}
+    func sendGalleryMode() {}
+    func requestVersionInfo() {}
+    func sendIncidentId(_: String, apiBaseUrl _: String?) {}
+}

package/ios/Tests/G1PairingTests.swift

@@ -0,0 +1,162 @@
+import CoreBluetooth
+@testable import MentraBluetoothSDK
+import XCTest
+
+@MainActor
+final class G1PairingTests: XCTestCase {
+    /// Exercise the real discovery/readiness entry points without accessing a
+    /// radio. Battery requests are observed through the SDK diagnostics.
+    private class RecordingG1: G1 {
+        var scans = 0
+        override func startScan() -> Bool {
+            scans += 1
+            return false // Central manager is still initializing.
+        }
+    }
+
+    private func withGlasses(_ test: (RecordingG1) async throws -> Void) async rethrows {
+        let store = DeviceStore.shared.store
+        let saved = store.getCategory("glasses")
+        let keys = ["leftGlassUUID", "rightGlassUUID", "leftGlassSearchID", "rightGlassSearchID"]
+        let savedDefaults = keys.map { ($0, UserDefaults.standard.object(forKey: $0)) }
+        let glasses = RecordingG1()
+        defer {
+            glasses.forget()
+            for (key, value) in savedDefaults {
+                UserDefaults.standard.set(value, forKey: key)
+            }
+            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)
+            }
+        }
+        try await test(glasses)
+    }
+
+    func testFirstDiscoveryResumesWhenBluetoothPowersOn() async {
+        await withGlasses { glasses in
+            glasses.findCompatibleDevices()
+            XCTAssertEqual(glasses.DEVICE_SEARCH_ID, "NOT_SET")
+            XCTAssertEqual(glasses.scans, 1)
+            glasses.handleBluetoothState(.poweredOn)
+            XCTAssertEqual(glasses.scans, 2)
+        }
+    }
+
+    func testStoppedDiscoveryDoesNotResumeOnLatePowerCallback() async {
+        await withGlasses { glasses in
+            glasses.findCompatibleDevices()
+            glasses.stopScan()
+            glasses.handleBluetoothState(.poweredOn)
+            XCTAssertEqual(glasses.scans, 1)
+        }
+    }
+
+    func testSelectedPairResumesButCancelledPairDoesNot() async {
+        await withGlasses { glasses in
+            glasses.connectById("59")
+            glasses.handleBluetoothState(.poweredOn)
+            XCTAssertEqual(glasses.scans, 2)
+            XCTAssertEqual(glasses.DEVICE_SEARCH_ID, "_59_")
+            // Finding both arms stops scanning, but should not prevent a
+            // selected pair from reconnecting after Bluetooth is toggled.
+            glasses.stopScan()
+            glasses.handleBluetoothState(.poweredOff)
+            glasses.handleBluetoothState(.poweredOn)
+            XCTAssertEqual(glasses.scans, 3)
+            glasses.disconnect()
+            glasses.handleBluetoothState(.poweredOn)
+            XCTAssertEqual(glasses.scans, 3)
+        }
+    }
+
+    func testBatteryWaitsForBothArmsAndRefreshesAfterReconnect() async {
+        await withGlasses { glasses in
+            var batteryRequests = 0
+            let sink = Bridge.addEventSink { event, body in
+                if event == "log", body["message"] as? String == "G1: getBatteryStatus()" {
+                    batteryRequests += 1
+                }
+            }
+            defer { Bridge.removeEventSink(sink) }
+            glasses.getBatteryStatus()
+            XCTAssertEqual(batteryRequests, 0)
+            glasses.setReadiness(left: true, right: nil)
+            glasses.getBatteryStatus()
+            XCTAssertEqual(batteryRequests, 0)
+            glasses.setReadiness(left: nil, right: true)
+            XCTAssertEqual(batteryRequests, 1)
+            glasses.setReadiness(left: true, right: true)
+            XCTAssertEqual(batteryRequests, 1, "Duplicate init ACKs must not poll again")
+            glasses.setReadiness(left: false, right: false)
+            glasses.getBatteryStatus()
+            XCTAssertEqual(batteryRequests, 1)
+            glasses.setReadiness(left: nil, right: true)
+            glasses.setReadiness(left: true, right: nil)
+            XCTAssertEqual(batteryRequests, 2)
+        }
+    }
+
+    func testQueuedCommandWithoutTransportDoesNotReconnect() async throws {
+        try await withGlasses { glasses in
+            glasses.queueChunks([[Commands.BLE_REQ_BATTERY.rawValue, 0x01]])
+            // The original missing-characteristic path restarted scanning after
+            // five 100ms command attempts, before either arm could connect.
+            try await Task.sleep(nanoseconds: 1_000_000_000)
+            XCTAssertEqual(glasses.scans, 0)
+        }
+    }
+}
+
+final class G1ReconnectionTests: XCTestCase {
+    func testSuccessfulReconnectAllowsALaterRetryLoop() async {
+        let manager = ReconnectionManager()
+        let connected = expectation(description: "Reconnect completes")
+        await manager.start {
+            connected.fulfill()
+            return true
+        }
+        await fulfillment(of: [connected], timeout: 1)
+        let running = await manager.isRunning
+        XCTAssertFalse(running)
+
+        let retry = expectation(description: "A later disconnection can reconnect")
+        await manager.start {
+            retry.fulfill()
+            return true
+        }
+        await fulfillment(of: [retry], timeout: 1)
+        await manager.stop()
+    }
+
+    func testRepeatedFailuresDoNotRestartTheRetryDelay() async {
+        let manager = ReconnectionManager(intervalSeconds: 60)
+        let firstAttempt = expectation(description: "First reconnect attempt")
+        await manager.start {
+            firstAttempt.fulfill()
+            return false
+        }
+        await fulfillment(of: [firstAttempt], timeout: 1)
+
+        let restarted = expectation(description: "No immediate retry for another failed command")
+        restarted.isInverted = true
+        await manager.start {
+            restarted.fulfill()
+            return false
+        }
+        await fulfillment(of: [restarted], timeout: 0.1)
+        let attempts = await manager.attemptCount
+        XCTAssertEqual(attempts, 1)
+        await manager.stop()
+
+        let nextAttempt = expectation(description: "A later connection can retry")
+        await manager.start {
+            nextAttempt.fulfill()
+            return false
+        }
+        await fulfillment(of: [nextAttempt], timeout: 1)
+        await manager.stop()
+    }
+}