@mentra/bluetooth-sdk 3.2.1-beta.459 → 3.2.1-beta.467

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/status/DeviceStatus.swift

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

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.459",
+  "version": "3.2.1-beta.467",
   "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.459"
+    "@mentra/cloud-protocol": "3.2.1-beta.467"
   },
   "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.459",
-  "releaseSetId": "mentra-3.2.1-beta.459",
-  "sourceCommit": "4e485930e223459b6c6f4a4f30072be409611f3d",
-  "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.459.json",
-  "otaManifestSha256": "82457abc1aa4faa1aea0ff67b2e90ab5a5cb180a6ee1945e92465305124445e9"
+  "releaseIdentity": "3.2.1-beta.467",
+  "releaseSetId": "mentra-3.2.1-beta.467",
+  "sourceCommit": "29ca2d88d95e44f372c74aaab73299dd9ed75745",
+  "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.467.json",
+  "otaManifestSha256": "2db9f33a4be723fb637cd2fba163003d5f2b276a9995f7fe576c194e0512353c"
 })