@mentra/bluetooth-sdk 3.2.1-beta.455 → 3.2.1-beta.464

package/ios/Source/sgcs/G2ConnectionSession.swift

@@ -0,0 +1,101 @@
+import Foundation
+
+/// Readiness belongs to an authenticated pair and a completed initialization attempt, never to
+/// a gesture from one arm. A generation retires asynchronous setup when either arm is lost.
+struct G2ConnectionSession {
+    enum Side: String, CaseIterable {
+        case left = "L"
+        case right = "R"
+    }
+
+    private(set) var generation: UInt64 = 0
+    private var initialized: Set<Side> = []
+    private var authenticatedSides: Set<Side> = []
+    private var authStarted = false
+    private var setupComplete = false
+
+    var isReady: Bool {
+        initialized.count == 2 && authenticatedSides.count == 2 && setupComplete
+    }
+
+    func needsRecovery(attempt: UInt64) -> Bool {
+        generation == attempt && !isReady
+    }
+
+    mutating func initialize(_ side: Side) {
+        initialized.insert(side)
+    }
+
+    mutating func beginAuthentication() -> UInt64? {
+        guard initialized.count == 2, !authStarted else { return nil }
+        authStarted = true
+        return generation
+    }
+
+    mutating func authenticated(_ side: Side, success: Bool) {
+        guard authStarted else { return }
+        if success { authenticatedSides.insert(side) }
+        else { authenticatedSides.remove(side) }
+    }
+
+    mutating func completeSetup(generation: UInt64) {
+        guard self.generation == generation, authStarted else { return }
+        setupComplete = true
+    }
+
+    mutating func reset() {
+        generation &+= 1
+        initialized.removeAll()
+        authenticatedSides.removeAll()
+        authStarted = false
+        setupComplete = false
+    }
+}
+
+enum G2ConnectionTarget {
+    /// A serial-scoped cached UUID identifies an arm even without a new advertisement. Nearby
+    /// arms can share the G2_32 name fragment; only an advertisement's serial can select an
+    /// uncached arm. Never fall back to names alone or another pair's cached identifiers.
+    static func side(
+        identifier: UUID, name: String?, advertisedSerial: String?, searchID: String,
+        leftUUID: UUID?, rightUUID: UUID?
+    ) -> G2ConnectionSession.Side? {
+        guard !searchID.isEmpty, searchID != "NOT_SET" else { return nil }
+        if identifier == leftUUID, identifier == rightUUID { return nil }
+        if identifier == leftUUID { return .left }
+        if identifier == rightUUID { return .right }
+        guard let advertisedSerial, advertisedSerial.contains(searchID), let name else { return nil }
+        if name.contains("_L_") { return .left }
+        if name.contains("_R_") { return .right }
+        return nil
+    }
+}
+
+/// Normal pairing connects the arms sequentially. Surface a missing arm only after the
+/// same partial link has persisted for three seconds, using monotonic time.
+struct G2PartialConnection {
+    static let noticeDelay: TimeInterval = 3
+    private(set) var missingSide: G2ConnectionSession.Side?
+    private var partialSince: TimeInterval = 0
+
+    mutating func update(leftConnected: Bool, rightConnected: Bool, now: TimeInterval) {
+        let missing: G2ConnectionSession.Side? = leftConnected == rightConnected
+            ? nil : (leftConnected ? .right : .left)
+        if missing != missingSide {
+            missingSide = missing
+            partialSince = now
+        }
+    }
+
+    func visibleMissingSide(now: TimeInterval) -> G2ConnectionSession.Side? {
+        now - partialSince >= Self.noticeDelay ? missingSide : nil
+    }
+
+    var timeoutError: String {
+        switch missingSide {
+        case .left: "errors:g2LeftArmUnavailable"
+        case .right: "errors:g2RightArmUnavailable"
+        case nil: "errors:g2ConnectionTimedOut"
+        }
+    }
+}

package/ios/Source/sgcs/Nimo.swift

@@ -1543,7 +1543,7 @@ class Nimo: NSObject, SGCManager {
         guard let opusDecoder else { return }
         for opusFrame in packet.opusFrames {
             if let pcm = opusDecoder.decode(opusFrame), !pcm.isEmpty {
-                DeviceManager.shared.handlePcm(pcm)
+                DeviceManager.shared.handleGlassesPcm(pcm)
             }
         }
     }

package/ios/Source/status/DeviceStatus.swift

@@ -123,6 +123,7 @@ struct GlassesStatus: CustomStringConvertible {
             "wifiLocalIp": "",
             "signalStrength": -1,
             "signalStrengthUpdatedAt": 0,
+            "g2MissingArm": NSNull(),
         ]))
     }
 

package/ios/Tests/DeviceManagerReconnectTests.swift

@@ -0,0 +1,337 @@
+@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"]
+
+    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 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(_: Int, _: Int) {}
+    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/G2ConnectionSessionTests.swift

@@ -0,0 +1,172 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class G2ConnectionSessionTests: XCTestCase {
+    func testEitherArmAloneCannotStartAuthenticationOrBecomeReady() {
+        for side in G2ConnectionSession.Side.allCases {
+            var session = G2ConnectionSession()
+            session.initialize(side)
+            XCTAssertNil(session.beginAuthentication())
+            session.authenticated(side, success: true)
+            session.completeSetup(generation: session.generation)
+            XCTAssertFalse(session.isReady)
+        }
+    }
+
+    func testReadinessWaitsForBothAuthenticationResponsesAndCompletedSetup() throws {
+        for completeSetupFirst in [false, true] {
+            var session = G2ConnectionSession()
+            session.initialize(.right)
+            session.initialize(.left)
+            let generation = try XCTUnwrap(session.beginAuthentication())
+            XCTAssertNil(session.beginAuthentication(), "Duplicate service callbacks must not restart setup")
+            if completeSetupFirst { session.completeSetup(generation: generation) }
+            session.authenticated(.left, success: true)
+            session.authenticated(.right, success: false)
+            XCTAssertFalse(session.isReady)
+            session.authenticated(.right, success: true)
+            XCTAssertEqual(session.isReady, completeSetupFirst)
+            session.completeSetup(generation: generation)
+            XCTAssertTrue(session.isReady)
+        }
+    }
+
+    func testDisconnectRetiresAuthenticationAndSuspendedSetup() throws {
+        var session = G2ConnectionSession()
+        session.initialize(.left)
+        session.initialize(.right)
+        let oldGeneration = try XCTUnwrap(session.beginAuthentication())
+        session.authenticated(.left, success: true)
+        session.reset()
+        session.authenticated(.right, success: true)
+        session.completeSetup(generation: oldGeneration)
+        XCTAssertFalse(session.isReady)
+
+        session.initialize(.left)
+        session.initialize(.right)
+        let newGeneration = try XCTUnwrap(session.beginAuthentication())
+        session.authenticated(.left, success: true)
+        session.authenticated(.right, success: true)
+        session.completeSetup(generation: oldGeneration)
+        XCTAssertFalse(session.isReady, "Old setup cannot complete the replacement attempt")
+        session.completeSetup(generation: newGeneration)
+        XCTAssertTrue(session.isReady)
+    }
+
+    func testAttemptDeadlineCoversBothPartialPairsAndIncompleteAuthentication() throws {
+        for sides: [G2ConnectionSession.Side] in [[], [.left], [.right], [.left, .right]] {
+            var session = G2ConnectionSession()
+            for side in sides {
+                session.initialize(side)
+            }
+            _ = session.beginAuthentication()
+            let attempt = session.generation
+            XCTAssertTrue(session.needsRecovery(attempt: attempt))
+            session.reset()
+            XCTAssertFalse(session.needsRecovery(attempt: attempt), "A retired deadline cannot reset a new attempt")
+        }
+        var ready = G2ConnectionSession()
+        ready.initialize(.left)
+        ready.initialize(.right)
+        let attempt = try XCTUnwrap(ready.beginAuthentication())
+        ready.authenticated(.left, success: true)
+        ready.authenticated(.right, success: true)
+        ready.completeSetup(generation: attempt)
+        XCTAssertFalse(ready.needsRecovery(attempt: attempt))
+    }
+
+    func testCachedArmsCanReconnectIndependentlyWithoutAdvertisements() {
+        let left = UUID(), right = UUID()
+        XCTAssertEqual(target(left, left: left), .left)
+        XCTAssertEqual(target(right, right: right), .right)
+        XCTAssertNil(target(UUID(), left: left, right: right))
+        XCTAssertNil(target(right, left: right, right: right), "Ambiguous cache must not bind one arm twice")
+    }
+
+    func testOnlySelectedSerialCanFillTheMissingArm() {
+        let id = UUID()
+        XCTAssertEqual(target(id, name: "Even G2_32_L_123456", serial: "S211SELECTED"), .left)
+        XCTAssertNil(target(id, name: "Even G2_32_L_123456", serial: "S211OTHER"))
+        XCTAssertNil(target(id, name: "Even G2_32_R_123456"))
+        XCTAssertNil(target(id, right: id, searchID: "NOT_SET"))
+        XCTAssertNil(target(id, right: id, searchID: ""))
+    }
+
+    private func target(
+        _ id: UUID, name: String? = nil, serial: String? = nil,
+        left: UUID? = nil, right: UUID? = nil, searchID: String = "S211SELECTED"
+    ) -> G2ConnectionSession.Side? {
+        G2ConnectionTarget.side(identifier: id, name: name, advertisedSerial: serial,
+                                searchID: searchID, leftUUID: left, rightUUID: right)
+    }
+}
+
+@MainActor
+final class G2PrematureReadinessTests: XCTestCase {
+    func testSystemExitAndTouchBeforePairInitializationDoNotPublishReady() {
+        let store = DeviceStore.shared.store
+        let connected = store.get("glasses", "connected")
+        let booted = store.get("glasses", "fullyBooted")
+        defer {
+            if let connected { store.set("glasses", "connected", connected) }
+            if let booted { store.set("glasses", "fullyBooted", booted) }
+        }
+        store.set("glasses", "connected", false)
+        store.set("glasses", "fullyBooted", false)
+        let g2 = G2()
+        // SendDeviceEvent.SysEvent { eventType: systemExit }, as observed on the right arm.
+        g2.handleTouchEvent(Data([0x1A, 0x02, 0x08, 0x07]))
+        XCTAssertEqual(store.get("glasses", "connected") as? Bool, false)
+        XCTAssertEqual(store.get("glasses", "fullyBooted") as? Bool, false)
+        g2.handleTouchEvent(Data([0x1A, 0x02, 0x08, 0x00]))
+        XCTAssertEqual(store.get("glasses", "connected") as? Bool, false)
+        XCTAssertEqual(store.get("glasses", "fullyBooted") as? Bool, false)
+    }
+}
+
+final class G2PartialConnectionTests: XCTestCase {
+    func testEitherPartialLinkStaysQuietForThreeSeconds() {
+        for leftConnected in [false, true] {
+            var progress = G2PartialConnection()
+            progress.update(leftConnected: leftConnected, rightConnected: !leftConnected, now: 10)
+            XCTAssertNil(progress.visibleMissingSide(now: 10))
+            XCTAssertNil(progress.visibleMissingSide(now: 12.999))
+            // Duplicate observations must not restart the grace period.
+            progress.update(leftConnected: leftConnected, rightConnected: !leftConnected, now: 12)
+            XCTAssertEqual(progress.visibleMissingSide(now: 13), leftConnected ? .right : .left)
+            XCTAssertEqual(progress.timeoutError, leftConnected ? "errors:g2RightArmUnavailable" : "errors:g2LeftArmUnavailable")
+        }
+    }
+
+    func testNormalSequentialPairingAndDisconnectedStateNeverShowMissingArm() {
+        var progress = G2PartialConnection()
+        progress.update(leftConnected: false, rightConnected: true, now: 10)
+        progress.update(leftConnected: true, rightConnected: true, now: 12)
+        XCTAssertNil(progress.visibleMissingSide(now: 15))
+        progress.update(leftConnected: false, rightConnected: false, now: 16)
+        XCTAssertNil(progress.visibleMissingSide(now: 20))
+        XCTAssertEqual(progress.timeoutError, "errors:g2ConnectionTimedOut")
+    }
+
+    func testPeerArrivalClearsVisibleNoticeAndNewPartialLinkGetsOwnGracePeriod() {
+        var progress = G2PartialConnection()
+        progress.update(leftConnected: true, rightConnected: false, now: 10)
+        XCTAssertEqual(progress.visibleMissingSide(now: 13), .right)
+        progress.update(leftConnected: true, rightConnected: true, now: 14)
+        XCTAssertNil(progress.visibleMissingSide(now: 14))
+        progress.update(leftConnected: false, rightConnected: true, now: 15)
+        XCTAssertNil(progress.visibleMissingSide(now: 17))
+        XCTAssertEqual(progress.visibleMissingSide(now: 18), .left)
+        progress = G2PartialConnection()
+        XCTAssertNil(progress.visibleMissingSide(now: 100))
+    }
+
+    func testStatusSnapshotAndUpdateCarryNoticeAndDisconnectClearsIt() throws {
+        let status = GlassesStatus(values: ["g2MissingArm": "left"])
+        XCTAssertEqual(status.dictionary["g2MissingArm"] as? String, "left")
+        XCTAssertEqual(GlassesStatusUpdate(values: ["g2MissingArm": "right"]).dictionary["g2MissingArm"] as? String, "right")
+        let disconnected = status.disconnected().dictionary
+        XCTAssertTrue(disconnected["g2MissingArm"] is NSNull)
+        XCTAssertNoThrow(try JSONSerialization.data(withJSONObject: disconnected))
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "3.2.1-beta.455",
+  "version": "3.2.1-beta.464",
   "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-beta.455"
+    "@mentra/cloud-protocol": "3.2.1-beta.464"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",

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"},
@@ -1613,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

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface BluetoothSdkReleaseMetadata {
 export const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "3.2.1",
-  "releaseIdentity": "3.2.1-beta.455",
-  "releaseSetId": "mentra-3.2.1-beta.455",
-  "sourceCommit": "07da1db49bab0ceacbcea480102309b8e8ae5bc6",
-  "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.455.json",
-  "otaManifestSha256": "0e3867266f9f3836f06b9ce574e6c3870f0864087e219002e424f54f194934e0"
+  "releaseIdentity": "3.2.1-beta.464",
+  "releaseSetId": "mentra-3.2.1-beta.464",
+  "sourceCommit": "02a42222a7f1d3807325cf6c8d081b8738aaf213",
+  "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.464.json",
+  "otaManifestSha256": "a55ad585f02ca9c63f7a8dde6f845516bdc1dcba36dad930001df69917856c15"
 })