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

package/ios/Tests/NimoCanvasTransportTests.swift

@@ -0,0 +1,186 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+private final class NimoTestClock {
+    private final class Job {
+        let time: TimeInterval
+        let task: () -> Void
+        var cancelled = false
+        init(_ time: TimeInterval, _ task: @escaping () -> Void) {
+            self.time = time; self.task = task
+        }
+    }
+
+    private var now: TimeInterval = 0
+    private var jobs: [Job] = []
+    lazy var schedule: NimoScheduler = { [unowned self] delay, task in
+        let job = Job(self.now + delay, task)
+        self.jobs.append(job)
+        return { job.cancelled = true }
+    }
+
+    func advance(_ seconds: TimeInterval = 0) {
+        let end = now + seconds
+        while let job = jobs.filter({ !$0.cancelled && $0.time <= end }).min(by: { $0.time < $1.time }) {
+            jobs.removeAll { $0 === job }
+            now = job.time
+            job.task()
+        }
+        now = end
+    }
+}
+
+final class NimoCanvasTransportTests: XCTestCase {
+    private let frame = Data([0, 0, 1])
+
+    func testNotReadyProbesAreTimedBoundedAndCancelled() {
+        for stop in ["budget", "disconnect", "exit", "notReady"] {
+            let clock = NimoTestClock()
+            var keys: [Int] = []
+            let canvas = NimoCanvasCoordinator(schedule: clock.schedule, writeCapacity: { 512 }, enqueue: { frames, start, complete in
+                keys.append(Int(frames[0][9])); start(); complete(); return true
+            }, reconnect: { XCTFail($0) }, rejected: { _ in })
+            canvas.activate(); canvas.readiness(true)
+            for attempt in 0 ..< 4 {
+                canvas.response(key: 1, payload: Data([7]))
+                if stop == "disconnect" { canvas.disconnected() }
+                if stop == "exit" { canvas.exit() }
+                if stop == "notReady" { canvas.readiness(false) }
+                let before = keys.count
+                clock.advance(0.999)
+                XCTAssertEqual(keys.count, before)
+                clock.advance(0.001)
+                XCTAssertEqual(keys.count, before + (stop == "budget" && attempt < 3 ? 1 : 0))
+                if stop != "budget" { break }
+            }
+            clock.advance(60)
+            XCTAssertEqual(keys.count, stop == "budget" ? 4 : 1)
+        }
+    }
+
+    func testEarlyAckOnlyAdvancesAfterFinalWriteCompletes() {
+        let clock = NimoTestClock()
+        var chains: [[Data]] = [], starts: [() -> Void] = [], completes: [() -> Void] = []
+        let canvas = NimoCanvasCoordinator(schedule: clock.schedule, writeCapacity: { 20 }, enqueue: { frames, start, complete in
+            chains.append(frames); starts.append(start); completes.append(complete); return true
+        }, reconnect: { XCTFail($0) }, rejected: { XCTFail("Unexpected rejection \($0)") })
+        canvas.offer(frame, scope: "app")
+        canvas.readiness(true)
+        canvas.response(key: 1, payload: Data([0, 0xFD])) // Before final fragment: ignore.
+        starts[0]()
+        XCTAssertEqual(chains.count, 1)
+        canvas.response(key: 1, payload: Data([0, 0xFD])) // Before GATT callback: buffer.
+        XCTAssertEqual(chains.count, 1)
+        completes[0]()
+        XCTAssertEqual(chains.count, 2)
+        XCTAssertEqual(chains[1][0][9], 4)
+        starts[1](); completes[1]()
+        canvas.response(key: 4, payload: Data([0, 0xFD, 0, 0, 0]))
+        clock.advance(60)
+    }
+
+    func testTimeoutAndOldCompletionCannotAdvanceNewGeneration() {
+        let clock = NimoTestClock()
+        var completions: [() -> Void] = [], reasons: [String] = [], count = 0
+        let canvas = NimoCanvasCoordinator(schedule: clock.schedule, writeCapacity: { 512 }, enqueue: { _, start, complete in
+            count += 1; start(); completions.append(complete); return true
+        }, reconnect: { reasons.append($0) }, rejected: { _ in })
+        canvas.offer(frame, scope: "app"); canvas.readiness(true)
+        clock.advance(45)
+        XCTAssertEqual(reasons.count, 1)
+        canvas.readiness(true)
+        completions[0]()
+        canvas.response(key: 1, payload: Data([0, 0xFD]))
+        XCTAssertEqual(count, 2) // ACK buffered for the new flight until its own write completes.
+        completions[1]()
+        XCTAssertEqual(count, 3)
+        canvas.disconnected()
+    }
+
+    func testQueueWatchdogRetiresRatherThanSkippingFragment() {
+        let clock = NimoTestClock(), connection = NSObject(), characteristic = NSObject()
+        var bytes: [Data] = [], failures: [String] = []
+        let queue = NimoWriteQueue<NSObject>(schedule: clock.schedule, write: { _, data in bytes.append(data); return true }, failure: { failures.append($0) })
+        queue.connected(connection)
+        queue.enqueue(connection, characteristic: characteristic, frames: [Data([1]), Data([2])])
+        clock.advance(3)
+        XCTAssertEqual(bytes, [Data([1])]); XCTAssertEqual(failures, ["GATT write timed out"])
+        queue.written(connection, characteristic: characteristic, success: true)
+        clock.advance(1)
+        XCTAssertEqual(bytes.count, 1)
+    }
+
+    func testQueueRejectsOldPeripheralAndCharacteristicAndPacesWrites() {
+        let clock = NimoTestClock(), old = NSObject(), current = NSObject(), characteristic = NSObject()
+        var count = 0, completed = 0
+        let queue = NimoWriteQueue<NSObject>(schedule: clock.schedule, write: { _, _ in count += 1; return true }, failure: { XCTFail($0) })
+        queue.connected(old)
+        queue.enqueue(old, characteristic: characteristic, frames: [Data([0])])
+        queue.connected(current)
+        queue.enqueue(current, characteristic: characteristic, frames: [Data([1]), Data([2])], completed: { completed += 1 })
+        queue.written(old, characteristic: characteristic, success: true)
+        queue.written(current, characteristic: NSObject(), success: true)
+        clock.advance(0.01)
+        XCTAssertEqual(count, 2)
+        queue.written(current, characteristic: characteristic, success: true)
+        clock.advance(0.004)
+        XCTAssertEqual(count, 2)
+        clock.advance(0.001)
+        XCTAssertEqual(count, 3)
+        queue.written(current, characteristic: characteristic, success: true)
+        clock.advance(0.005)
+        XCTAssertEqual(completed, 1)
+        clock.advance(10)
+    }
+
+    func testGattErrorAbortsRemainingChain() {
+        let clock = NimoTestClock(), connection = NSObject(), characteristic = NSObject()
+        var count = 0, failures = 0
+        let queue = NimoWriteQueue<NSObject>(schedule: clock.schedule, write: { _, _ in count += 1; return true }, failure: { _ in failures += 1 })
+        queue.connected(connection)
+        queue.enqueue(connection, characteristic: characteristic, frames: [Data([1]), Data([2])])
+        queue.written(connection, characteristic: characteristic, success: false)
+        clock.advance(4)
+        XCTAssertEqual(count, 1); XCTAssertEqual(failures, 1)
+    }
+
+    func testLatestOnlyEncoderAndExitFenceRunningResults() {
+        let main = NimoTestClock(), worker = NimoTestClock()
+        var delivered: [Data] = [], encoded = 0
+        let encoder = NimoCanvasEncoder(main: main.schedule, worker: worker.schedule, failure: { XCTFail("\($0)") })
+        encoder.submit(encode: { encoded += 1; return Data([1]) }, deliver: { delivered.append($0) })
+        encoder.submit(encode: { encoded += 1; return Data([2]) }, deliver: { delivered.append($0) })
+        worker.advance()
+        XCTAssertEqual(encoded, 1)
+        encoder.invalidate() // Exit/disconnect while the finished encode awaits Main.
+        main.advance()
+        XCTAssertTrue(delivered.isEmpty)
+        encoder.submit(encode: { Data([3]) }, deliver: { delivered.append($0) })
+        worker.advance(); main.advance()
+        XCTAssertEqual(delivered, [Data([3])])
+    }
+
+    func testCompleteSceneThroughWriteQueueAndBusinessAcks() throws {
+        let clock = NimoTestClock(), connection = NSObject(), characteristic = NSObject()
+        var written: [Data] = []
+        let queue = NimoWriteQueue<NSObject>(schedule: clock.schedule, write: { _, data in written.append(data); return true }, failure: { XCTFail($0) })
+        queue.connected(connection)
+        let canvas = NimoCanvasCoordinator(schedule: clock.schedule, writeCapacity: { 20 }, enqueue: { frames, started, completed in
+            queue.enqueue(connection, characteristic: characteristic, frames: frames, finalStarted: started, completed: completed)
+        }, reconnect: { XCTFail($0) }, rejected: { XCTFail("Rejected \($0)") })
+        let content = try NimoCanvasCodec.replace([NimoCanvasCodec.label("Captions", 0, 0, 500, 20)])
+        canvas.offer(content, scope: "captions:1"); canvas.readiness(true)
+        queue.written(connection, characteristic: characteristic, success: true); clock.advance(0.005)
+        let launchAck = Data([0, 0xFD])
+        canvas.response(key: 1, payload: launchAck)
+        let expected = try NimoCanvasCodec.frames(key: 4, content: content, writeCapacity: 20)
+        for _ in expected {
+            queue.written(connection, characteristic: characteristic, success: true); clock.advance(0.005)
+        }
+        XCTAssertEqual(Array(written.dropFirst()), expected)
+        canvas.response(key: 4, payload: Data([0, 0xFD, 0, 0, 0]))
+        canvas.offer(content, scope: "captions:1")
+        XCTAssertEqual(written.count, expected.count + 1)
+        canvas.disconnected(); queue.reset()
+    }
+}

package/ios/Tests/NimoDeviceCommandsTests.swift

@@ -0,0 +1,16 @@
+import Foundation
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class NimoDeviceCommandsTests: XCTestCase {
+    func testSystemEnglishAndFactoryResetMatchFirmwareWireCommands() {
+        func hex(_ bytes: Data) -> String {
+            bytes.map { String(format: "%02X", $0) }.joined()
+        }
+        XCTAssertEqual(hex(NimoFrameCodec.encodeFrame(cmd: NimoProtocol.CMD_SET_PARAMETER,
+                                                      key: NimoProtocol.SET_SYSTEM_LANGUAGE, payload: Data([NimoProtocol.LANGUAGE_ENGLISH]))),
+                       "BF020500702500000324010001")
+        XCTAssertEqual(hex(NimoFrameCodec.encodeFrame(cmd: NimoProtocol.CMD_CONTROL_FACTORY,
+                                                      key: NimoProtocol.FACTORY_RECOVER, payload: Data())), "BF0204005358000008030000")
+    }
+}

package/ios/Tests/NimoDiscoveryTests.swift

@@ -0,0 +1,79 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+@MainActor
+final class NimoDiscoveryTests: XCTestCase {
+    @MainActor
+    private final class Radio {
+        var connected: [String] = []
+        var events: [String] = []
+        var found: [String] = []
+        var selected: String?
+        lazy var discovery: NimoDiscovery<String> = NimoDiscovery(
+            register: { [unowned self] in self.events.append("register") },
+            connected: { [unowned self] in self.events.append("retrieve"); return self.connected },
+            scan: { [unowned self] in self.events.append("scan") },
+            stop: { [unowned self] in self.events.append("stop") },
+            name: { $0 },
+            found: { [unowned self] _, name, _ in
+                found.append(name)
+                if selected == name { discovery.cancel() }
+            }
+        )
+    }
+
+    func testAlreadyConnectedClassicDeviceIsFoundWithoutAdvertisement() {
+        let radio = Radio()
+        radio.connected = ["NIMO_1234", "NIMO_1234_BLE", "Unrelated"]
+        radio.discovery.start()
+        XCTAssertEqual(radio.events, ["register", "retrieve", "scan"])
+        XCTAssertEqual(radio.found, ["NIMO_1234"])
+    }
+
+    func testPairingInSettingsAfterScanStartedDeliversDevice() {
+        let radio = Radio()
+        radio.discovery.start()
+        XCTAssertTrue(radio.found.isEmpty)
+        // Same entry point as connectionEventDidOccur(.peerConnected).
+        radio.discovery.receive("NIMO_5678")
+        XCTAssertEqual(radio.found, ["NIMO_5678"])
+    }
+
+    func testSelectionFromConnectedSnapshotStopsBeforeStartingBleScan() {
+        let radio = Radio()
+        radio.selected = "NIMO_5678"
+        radio.connected = ["NIMO_1234", "NIMO_5678", "NIMO_9999"]
+        radio.discovery.start()
+        XCTAssertEqual(radio.found, ["NIMO_1234", "NIMO_5678"])
+        XCTAssertEqual(radio.events, ["register", "retrieve", "stop"])
+        XCTAssertFalse(radio.discovery.active)
+    }
+
+    func testCancelledDiscoveryIgnoresQueuedEventsAndCanRestart() {
+        let radio = Radio()
+        radio.discovery.start()
+        radio.discovery.cancel()
+        radio.discovery.receive("NIMO_1234")
+        XCTAssertTrue(radio.found.isEmpty)
+        radio.connected = ["NIMO_1234"]
+        radio.discovery.start()
+        XCTAssertEqual(radio.found, ["NIMO_1234"])
+    }
+
+    func testBleFallbackUsesAdvertisementNameAndPreservesSignalStrength() {
+        var found: [String] = []
+        var signal: Int?
+        let discovery = NimoDiscovery<String>(
+            register: {}, connected: { [] }, scan: {}, stop: {}, name: { _ in nil },
+            found: { _, name, rssi in found.append(name); signal = rssi }
+        )
+        discovery.start()
+        discovery.receive("uuid", advertisedName: "NiMo_1234_bLe", rssi: -60)
+        discovery.receive("uuid", advertisedName: "Unrelated", rssi: -60)
+        discovery.receive("uuid")
+        XCTAssertTrue(found.isEmpty)
+        discovery.receive("uuid", advertisedName: "NiMo_1234", rssi: -55)
+        XCTAssertEqual(found, ["NiMo_1234"])
+        XCTAssertEqual(signal, -55)
+    }
+}

package/ios/Tests/SGCConnectionTargetTests.swift

@@ -0,0 +1,48 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class SGCConnectionTargetTests: XCTestCase {
+    func testG1RejectsAnotherPairsLegacyUUID() {
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: "Even G1_12_L_123456", searchID: "_47_", cachedSearchID: nil))
+        XCTAssertTrue(G1ConnectionTarget.matchesCachedPeripheral(name: "Even G1_47_L_123456", searchID: "_47_", cachedSearchID: nil))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: "Even G1_470_R_123456", searchID: "_47_", cachedSearchID: nil))
+    }
+
+    func testG1NamelessBackgroundReconnectRequiresRecordedTarget() {
+        XCTAssertTrue(G1ConnectionTarget.matchesCachedPeripheral(name: nil, searchID: "_47_", cachedSearchID: "_47_"))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: nil, searchID: "_47_", cachedSearchID: "_12_"))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: nil, searchID: "_47_", cachedSearchID: nil))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: "Even G1_12_L_123456", searchID: "_47_", cachedSearchID: "_47_"))
+        XCTAssertFalse(G1ConnectionTarget.matchesCachedPeripheral(name: nil, searchID: "NOT_SET", cachedSearchID: "NOT_SET"))
+    }
+
+    func testNexExplicitSelectionExcludesSavedAndPreferredFallbacks() {
+        XCTAssertFalse(nex(name: "Nex1-old", target: "Nex1-new"))
+        XCTAssertFalse(nex(name: "Nex1-new-extra", target: "Nex1-new"))
+        XCTAssertTrue(nex(name: "Nex1-new", target: "Nex1-new"))
+        XCTAssertFalse(nex(name: "Nex1-old", target: ""))
+    }
+
+    func testNexDiscoveryNeverConnectsAndSavedReconnectStillWorks() {
+        XCTAssertFalse(nex(name: "Nex1-old", target: nil, discovery: true))
+        XCTAssertFalse(nex(name: "Nex1-new", target: "Nex1-new", discovery: true))
+        XCTAssertTrue(nex(name: "Nex1-old", target: nil))
+        XCTAssertTrue(nex(name: "Nex1-renamed", target: nil))
+    }
+
+    func testVuzixCurrentLinkMustMatchTheSelectedBracketedID() {
+        XCTAssertTrue(VuzixConnectionTarget.matches(name: "Vuzix Z100 [abc123]", target: "abc123"))
+        XCTAssertTrue(VuzixConnectionTarget.matches(name: "Vuzix Z100 [abc123]", target: "Vuzix Z100 [abc123]"))
+        XCTAssertFalse(VuzixConnectionTarget.matches(name: "Vuzix Z100 [old123]", target: "abc123"))
+        XCTAssertFalse(VuzixConnectionTarget.matches(name: nil, target: "abc123"))
+        XCTAssertFalse(VuzixConnectionTarget.matches(name: "", target: ""))
+        XCTAssertEqual(VuzixConnectionTarget.identifier("abc123"), "abc123")
+    }
+
+    private func nex(name: String, target: String?, discovery: Bool = false) -> Bool {
+        NexConnectionTarget.shouldConnect(
+            name: name, target: target, discoveryOnly: discovery,
+            savedName: "Nex1-old", preferredID: "old", discoveredID: "old"
+        )
+    }
+}

package/ios/Tests/VersionInfoCommandTests.swift

@@ -0,0 +1,53 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+@MainActor
+private final class VersionInfoCommandTransport: MentraLive {
+    var requestId: String?
+
+    override func sendJson(_ jsonOriginal: [String: Any], wakeUp: Bool, requireAck: Bool) {
+        XCTAssertEqual(jsonOriginal["type"] as? String, "request_version")
+        XCTAssertTrue(wakeUp, "An idle ASG must wake to finish its version response")
+        XCTAssertTrue(requireAck)
+        do {
+            let bytes = try JSONSerialization.data(withJSONObject: jsonOriginal)
+            let command = try XCTUnwrap(JSONSerialization.jsonObject(with: bytes) as? [String: Any])
+            let id = try XCTUnwrap(command["request_id"] as? String)
+            requestId = id
+            let common: [String: Any] = ["request_id": id, "sid": "asg-1", "chunkCount": 2]
+            for chunk: [String: Any] in [
+                ["type": "version_info_1", "chunkIndex": 1, "final": false,
+                 "build_number": "303000008", "app_version": "3.3.0"],
+                ["type": "version_info_3", "chunkIndex": 2, "final": true,
+                 "bes_fw_version": "26.9.23.0", "mtk_fw_version": "MentraLive_20260921.0"],
+            ] {
+                let response = common.merging(chunk) { _, value in value }
+                try processReceivedData(JSONSerialization.data(withJSONObject: response))
+            }
+        } catch {
+            XCTFail("Could not replay version request: \(error)")
+        }
+    }
+}
+
+@MainActor
+final class VersionInfoCommandTests: XCTestCase {
+    func testPublicVersionRequestWakesGlassesAndCombinesBothResponseChunks() async throws {
+        let previous = DeviceManager.shared.sgc
+        let transport = VersionInfoCommandTransport()
+        DeviceManager.shared.sgc = transport
+        let sdk = MentraBluetoothSDK()
+        defer {
+            sdk.invalidate()
+            DeviceManager.shared.sgc = previous
+        }
+
+        let result = try await sdk.requestVersionInfo()
+
+        XCTAssertNotNil(transport.requestId)
+        XCTAssertEqual(result.buildNumber, "303000008")
+        XCTAssertEqual(result.appVersion, "3.3.0")
+        XCTAssertEqual(result.besFirmwareVersion, "26.9.23.0")
+        XCTAssertEqual(result.mtkFirmwareVersion, "MentraLive_20260921.0")
+    }
+}

package/ios/Tests/VersionInfoResponseAccumulatorTests.swift

@@ -117,6 +117,71 @@ final class VersionInfoResponseAccumulatorTests: XCTestCase {
         }
     }
 
+    func testFactoryAsg27CompletesAfterItsTwoChunks() {
+        // Exact January wire shape after Bridge normalization; firmware can be unknown.
+        for firmware in ["", "17.26.1.13"] {
+            let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+            _ = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": "27", "appVersion": "27.0"]))
+            guard case let .complete(result) = accumulator.accept(chunk("version_info_2", nil, [
+                "buildNumber": "", "otaVersionUrl": "https://ota.example/live_version.json", "firmwareVersion": firmware,
+            ])) else { return XCTFail("ASG27 has no third chunk") }
+            XCTAssertEqual(result.buildNumber, "27")
+            XCTAssertEqual(result.otaVersionUrl, "https://ota.example/live_version.json")
+            XCTAssertEqual(result.firmwareVersion, firmware)
+        }
+    }
+
+    func testOtherLegacyBuildsStillRequireTheirThirdChunk() {
+        for build in ["", "26", "28", "31", "37", "42"] {
+            let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+            _ = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": build]))
+            guard case .waiting = accumulator.accept(chunk("version_info_2", nil, [
+                "otaVersionUrl": "https://ota.example/version.json",
+            ])) else { return XCTFail("Unknown or three-chunk builds must wait: " + build) }
+            guard case .complete = accumulator.accept(chunk("version_info_3", nil, ["besFirmwareVersion": "new"]))
+            else { return XCTFail("Legacy third chunk must complete") }
+        }
+    }
+
+    func testFactorySecondChunkCannotCompleteWithoutFirstChunkAndOtaUrl() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        let second = chunk("version_info_2", nil, ["otaVersionUrl": "https://ota.example/version.json"])
+        guard case .ignored = accumulator.accept(second) else { return XCTFail("Trailing chunk is stale") }
+        _ = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": "27"]))
+        for values in [[:], ["otaVersionUrl": ""], ["otaVersionUrl": " \n"]] as [[String: Any]] {
+            guard case .waiting = accumulator.accept(chunk("version_info_2", nil, values))
+            else { return XCTFail("Incomplete second chunk cannot complete") }
+        }
+        guard case .complete = accumulator.accept(second) else { return XCTFail("Actual terminal chunk") }
+    }
+
+    func testSecondChunkCannotChangeBuildIntoFactoryProtocol() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        _ = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": "31"]))
+        guard case .waiting = accumulator.accept(chunk("version_info_2", nil, [
+            "buildNumber": "27", "otaVersionUrl": "https://ota.example/version.json",
+        ])) else { return XCTFail("Only the first chunk declares the protocol") }
+    }
+
+    func testRepeatedFirstChunkClearsFactoryCompletionRule() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        _ = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": "27"]))
+        _ = accumulator.accept(chunk("version_info_1", nil, ["buildNumber": "31"]))
+        guard case .waiting = accumulator.accept(chunk("version_info_2", nil, [
+            "otaVersionUrl": "https://ota.example/version.json",
+        ])) else { return XCTFail("The latest first chunk determines the protocol") }
+    }
+
+    func testFactoryBuildCannotBypassModernCorrelation() {
+        let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
+        _ = accumulator.accept(chunk("version_info_1", "request-1", ["buildNumber": "27"]))
+        guard case .ignored = accumulator.accept(chunk("version_info_2", nil, [
+            "otaVersionUrl": "https://ota.example/version.json",
+        ])) else { return XCTFail("Uncorrelated terminal chunk cannot complete a modern request") }
+        guard case .complete = accumulator.accept(chunk("version_info_3", "request-1", ["besFirmwareVersion": "new"]))
+        else { return XCTFail("Modern completeness metadata remains authoritative") }
+    }
+
     func testModernFinalChunkWaitsForMissingFirstChunk() {
         let accumulator = VersionInfoResponseAccumulator(expectedRequestId: "request-1")
         guard case .waiting = accumulator.accept(chunk("version_info_3", "request-1", ["besFirmwareVersion": "new"])) else {

package/ios/Tests/VideoRecordingCommandTests.swift

@@ -0,0 +1,81 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+/// Replace the radio handoff while retaining public SDK dispatch and response handling.
+@MainActor
+private final class VideoRecordingCommandTransport: MentraLive {
+    var commands: [[String: Any]] = []
+
+    override func sendJson(_ jsonOriginal: [String: Any], wakeUp: Bool, requireAck: Bool) {
+        do {
+            let bytes = try JSONSerialization.data(withJSONObject: jsonOriginal)
+            let command = try XCTUnwrap(JSONSerialization.jsonObject(with: bytes) as? [String: Any])
+            let type = try XCTUnwrap(command["type"] as? String)
+            let requestId = try XCTUnwrap(command["requestId"] as? String)
+            commands.append(command)
+            XCTAssertTrue(wakeUp, "\(type) must wake the glasses before ASG can handle it")
+            XCTAssertTrue(requireAck)
+
+            let statuses = [
+                "start_video_recording": "recording_started",
+                "get_video_recording_status": "recording_status",
+                "stop_video_recording": "recording_stopped",
+            ]
+            let status = try XCTUnwrap(statuses[type])
+            let response: [String: Any] = [
+                "type": "video_recording_status", "requestId": requestId,
+                "status": status, "success": true,
+            ]
+            try processReceivedData(JSONSerialization.data(withJSONObject: response))
+        } catch {
+            XCTFail("Could not replay video recording command: \(error)")
+        }
+    }
+}
+
+@MainActor
+final class VideoRecordingCommandTests: XCTestCase {
+    func testStartStatusAndStopWakeGlassesThroughPublicSDK() async throws {
+        let previous = DeviceManager.shared.sgc
+        let store = DeviceStore.shared.store
+        let savedConnected = store.getCategory("glasses")["connected"]
+        let transport = VideoRecordingCommandTransport()
+        transport.connectionState = ConnTypes.CONNECTED
+        DeviceManager.shared.sgc = transport
+        DeviceStore.shared.apply("glasses", "connected", true)
+        let sdk = MentraBluetoothSDK()
+        defer {
+            sdk.invalidate()
+            DeviceManager.shared.sgc = previous
+            if let savedConnected {
+                store.set("glasses", "connected", savedConnected)
+            } else {
+                store.remove("glasses", "connected")
+            }
+        }
+
+        let requestId = "idle-recording"
+        let started = try await sdk.startVideoRecording(VideoRecordingRequest(
+            requestId: requestId, save: true, sound: false,
+            width: 1280, height: 720, fps: 30, maxRecordingTimeMinutes: 2
+        ))
+        XCTAssertEqual(started.status, "recording_started")
+        XCTAssertEqual(started.requestId, requestId)
+        let start = try XCTUnwrap(transport.commands.last)
+        XCTAssertEqual(start["save"] as? Bool, true)
+        XCTAssertEqual(start["sound"] as? Bool, false)
+        XCTAssertEqual(start["settings"] as? [String: Int], ["width": 1280, "height": 720, "fps": 30])
+        XCTAssertEqual(start["maxRecordingTimeMinutes"] as? Int, 2)
+
+        let status = try await sdk.queryVideoRecordingStatus(requestId: requestId)
+        XCTAssertEqual(status.status, "recording_status")
+        XCTAssertEqual(status.requestId, requestId)
+
+        let stopped = try await sdk.stopVideoRecording(requestId: requestId)
+        XCTAssertEqual(stopped.status, "recording_stopped")
+        XCTAssertEqual(stopped.requestId, requestId)
+        XCTAssertEqual(transport.commands.compactMap { $0["type"] as? String }, [
+            "start_video_recording", "get_video_recording_status", "stop_video_recording",
+        ])
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "3.2.1-dev.311",
+  "version": "3.2.1",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",
@@ -114,7 +114,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@mentra/cloud-protocol": "3.2.1-dev.311"
+    "@mentra/cloud-protocol": "3.2.1"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",

package/plugin/build/withIos.d.ts

@@ -2,5 +2,7 @@ import { IOSConfig, type ConfigPlugin } from "expo/config-plugins";
 import { type BluetoothSdkPluginProps } from "./index";
 export declare const INFO_ANALYTICS_ENVIRONMENT = "MentraBluetoothSdkAnalyticsEnvironment";
 export declare const INFO_SDK_VERSION = "MentraBluetoothSdkVersion";
+/** Lets iOS complete the SDK's pending reconnect, and deliver BLE events, while the app is suspended. */
+export declare const IOS_BLUETOOTH_BACKGROUND_MODE = "bluetooth-central";
 export declare function applyBluetoothSdkInfoPlist(infoPlist: IOSConfig.InfoPlist, props: BluetoothSdkPluginProps | undefined): IOSConfig.InfoPlist;
 export declare const withIosConfiguration: ConfigPlugin<BluetoothSdkPluginProps>;

package/plugin/build/withIos.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withIosConfiguration = exports.INFO_SDK_VERSION = exports.INFO_ANALYTICS_ENVIRONMENT = void 0;
+exports.withIosConfiguration = exports.IOS_BLUETOOTH_BACKGROUND_MODE = exports.INFO_SDK_VERSION = exports.INFO_ANALYTICS_ENVIRONMENT = void 0;
 exports.applyBluetoothSdkInfoPlist = applyBluetoothSdkInfoPlist;
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
@@ -17,6 +17,8 @@ exports.INFO_ANALYTICS_ENVIRONMENT = "MentraBluetoothSdkAnalyticsEnvironment";
 exports.INFO_SDK_VERSION = "MentraBluetoothSdkVersion";
 const STALE_INFO_POSTHOG_API_KEY = "MentraBluetoothSdkPostHogApiKey";
 const STALE_INFO_POSTHOG_HOST = "MentraBluetoothSdkPostHogHost";
+/** Lets iOS complete the SDK's pending reconnect, and deliver BLE events, while the app is suspended. */
+exports.IOS_BLUETOOTH_BACKGROUND_MODE = "bluetooth-central";
 const ensureBluetoothSdkExpoAdapterPodEnv = (podfile) => {
     if (podfile.includes(BLUETOOTH_SDK_EXPO_ADAPTER_ENV)) {
         return podfile;
@@ -70,6 +72,15 @@ function applyBluetoothSdkInfoPlist(infoPlist, props) {
     delete infoPlist[STALE_INFO_POSTHOG_API_KEY];
     delete infoPlist[STALE_INFO_POSTHOG_HOST];
     infoPlist[exports.INFO_SDK_VERSION] = sdkVersion;
+    // Merge, never replace: apps may also declare audio, location or other modes.
+    const declaredModes = infoPlist.UIBackgroundModes;
+    if (declaredModes !== undefined && !Array.isArray(declaredModes)) {
+        throw new Error("ios.infoPlist.UIBackgroundModes must be an array of background mode strings");
+    }
+    const backgroundModes = declaredModes ?? [];
+    if (!backgroundModes.includes(exports.IOS_BLUETOOTH_BACKGROUND_MODE)) {
+        infoPlist.UIBackgroundModes = [...backgroundModes, exports.IOS_BLUETOOTH_BACKGROUND_MODE];
+    }
     if (analytics.disabled !== undefined) {
         infoPlist[INFO_ANALYTICS_DISABLED] = analytics.disabled;
     }

package/src/BluetoothSdk.types.ts

@@ -82,6 +82,7 @@ export function isBusyGlassesConnectionStatus(status: GlassesConnectionStatus):
 export function createDisconnectedGlassesStatus(): Partial<GlassesStatus> {
   return {
     connection: {state: "disconnected"},
+    g2MissingArm: null,
     hotspot: {state: "disabled"},
     voiceActivityDetectionEnabled: DEFAULT_VOICE_ACTIVITY_DETECTION_ENABLED,
     wifi: {state: "disconnected"},
@@ -543,6 +544,15 @@ export type WearTuning = {
 export type WearStateEvent = {
   type: "wear_state"
   worn: boolean
+  /** Unworn countdown, present on firmware that reports it. Milliseconds. */
+  elapsedMs?: number
+  timeoutMs?: number
+  /** cs_swit type 11. Absent on older firmware. */
+  enabled?: boolean
+  /** Countdown is running (glasses are off the face and the feature is on). */
+  armed?: boolean
+  /** Clock is running, but charging, a call, OTA, or factory test is holding shutdown. */
+  inhibited?: boolean
 }
 
 /**
@@ -1417,6 +1427,7 @@ export interface BluetoothSdkPublicModule {
   setGalleryModeEnabled(enabled: boolean): Promise<SettingsAckSuccessEvent>
   setVoiceActivityDetectionEnabled(enabled: boolean): Promise<void>
   setLoudnessGateEnabled(enabled: boolean): Promise<void>
+  setAutoPowerOffEnabled(enabled: boolean): Promise<void>
   /**
    * @deprecated Sticky action-button photo presets are deprecated. Prefer per-request
    * `requestPhoto(...)` options (e.g. `mode: "text"` for text sensor size/crop, or explicit per-shot
@@ -1603,6 +1614,8 @@ export interface OtaProgress {
 }
 
 export interface GlassesStatus {
+  /** iOS G2 arm still disconnected after a three-second partial link; cleared on reset or both links. */
+  g2MissingArm?: "left" | "right" | null
   // state:
   connection: GlassesConnectionStatus
   micEnabled: boolean
@@ -1798,6 +1811,7 @@ export type BluetoothSettingsUpdate = Partial<{
   gallery_mode: boolean
   voice_activity_detection_enabled: boolean
   loudness_gate_enabled: boolean
+  auto_power_off_enabled: boolean
   /** Effective mic tuning only. `{}` means "reset to firmware defaults". */
   mic_tuning: MicTuning
   button_photo_size: ButtonPhotoSize