@mentra/bluetooth-sdk 3.3.0-dev.516 → 3.3.0-dev.523

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

@@ -20,10 +20,6 @@ enum NimoBLE {
     static let CHAR_RX = CBUUID(string: "00002022-0000-1000-8000-00805F9B34FB")
     static let CHAR_MIC = CBUUID(string: "00002025-0000-1000-8000-00805F9B34FB")
 
-    static let NAME_PREFIX = "nimo"
-    /// iOS ANCS side-channel devices advertise "<name>_ble" — never the data channel.
-    static let BLE_NAME_SUFFIX = "_ble"
-
     static let CHUNK_SIZE = 501
     static let INTER_FRAME_DELAY_MS = 5
 }
@@ -44,6 +40,8 @@ enum NimoProtocol {
     static let CMD_SET_PARAMETER = 0x03
     static let CMD_INSTRUCTION_REPORT = 0x06
     static let CMD_CONTROL_INSTRUCTION = 0x07
+    static let CMD_CONTROL_FACTORY = 0x08
+    static let FACTORY_RECOVER = 0x03
     static let CMD_CONTROL_NOTIFICATION = 0x09
 
     // get parameter keys
@@ -62,6 +60,9 @@ enum NimoProtocol {
     static let SET_DISPLAY_OFF = 0x0F
     static let SET_PHONE_TYPE = 0x14
     static let SET_HEIGHT_LEVEL = 0x17
+    // Dynamic-v1 firmware: 1-based UI locale; 1 selects English.
+    static let SET_SYSTEM_LANGUAGE = 0x24
+    static let LANGUAGE_ENGLISH: UInt8 = 0x01
 
     // control instruction keys
     static let CTRL_ENTER_APP = 0x01
@@ -591,6 +592,27 @@ class Nimo: NSObject, SGCManager {
     private var rxChar: CBCharacteristic?
     private var micChar: CBCharacteristic?
     private var isDisconnecting = false
+    private var scanRequested = false
+    private lazy var discovery = NimoDiscovery<CBPeripheral>(
+        register: { [weak self] in
+            #if os(iOS)
+                self?.centralManager?.registerForConnectionEvents(options: [.serviceUUIDs: [NimoBLE.SERVICE_UUID]])
+            #endif
+        }, connected: { [weak self] in
+            self?.centralManager?.retrieveConnectedPeripherals(withServices: [NimoBLE.SERVICE_UUID]) ?? []
+        }, scan: { [weak self] in
+            self?.centralManager?.scanForPeripherals(
+                withServices: nil, options: [CBCentralManagerScanOptionAllowDuplicatesKey: false]
+            )
+        }, stop: { [weak self] in
+            self?.centralManager?.stopScan()
+            #if os(iOS)
+                self?.centralManager?.registerForConnectionEvents(options: [:])
+            #endif
+        }, name: { $0.name }, found: { [weak self] peripheral, name, rssi in
+            self?.onDeviceFound(peripheral, name: name, rssi: rssi)
+        }
+    )
 
     /// Device search
     private var DEVICE_SEARCH_ID = "NOT_SET"
@@ -680,6 +702,8 @@ class Nimo: NSObject, SGCManager {
     func findCompatibleDevices() {
         Bridge.log("NIMO: findCompatibleDevices()")
         DEVICE_SEARCH_ID = "NOT_SET"
+        isDisconnecting = false
+        scanRequested = true
         DeviceStore.shared.apply("glasses", "connectionState", ConnTypes.SCANNING)
         startScan()
     }
@@ -687,6 +711,7 @@ class Nimo: NSObject, SGCManager {
     func connectById(_ id: String) {
         Bridge.log("NIMO: connectById(\(id))")
         DEVICE_SEARCH_ID = id
+        scanRequested = true
         DeviceStore.shared.apply("glasses", "connectionState", ConnTypes.CONNECTING)
         isDisconnecting = false
         startPairingTimeout()
@@ -694,7 +719,8 @@ class Nimo: NSObject, SGCManager {
     }
 
     func stopScan() {
-        centralManager?.stopScan()
+        scanRequested = false
+        discovery.cancel()
     }
 
     func disconnect() {
@@ -721,6 +747,27 @@ class Nimo: NSObject, SGCManager {
         DeviceStore.shared.apply("glasses", "connectionState", ConnTypes.DISCONNECTED)
     }
 
+    /// Explicit Unpair only; passive forget/cleanup must never reset the glasses.
+    func resetForUnpair(onResult: @escaping (Bool) -> Void) {
+        guard peripheral != nil, txChar != nil, handshakeState == .ready else {
+            Bridge.log("NIMO: unpair while offline; remote reset unavailable")
+            onResult(false)
+            return
+        }
+        isDisconnecting = true
+        stopTimers()
+        Task { await reconnectionManager.stop() }
+        canvasEncoder.invalidate()
+        canvas.disconnected()
+        Bridge.log("NIMO: sending factory reset for explicit Unpair")
+        sendAwaitingAck(cmd: NimoProtocol.CMD_CONTROL_FACTORY, key: NimoProtocol.FACTORY_RECOVER,
+                        payload: Data())
+        { success in
+            Bridge.log("NIMO: factory reset acknowledged=\(success)")
+            onResult(success)
+        }
+    }
+
     func forget() {
         Bridge.log("NIMO: forget()")
         disconnect()
@@ -1061,13 +1108,9 @@ class Nimo: NSObject, SGCManager {
 
     // MARK: - BLE Scanning
 
-    private func isNimoMainDevice(_ name: String) -> Bool {
-        let lower = name.lowercased()
-        return lower.hasPrefix(NimoBLE.NAME_PREFIX) && !lower.hasSuffix(NimoBLE.BLE_NAME_SUFFIX)
-    }
-
     @discardableResult
     private func startScan() -> Bool {
+        guard scanRequested, !isDisconnecting else { return false }
         Bridge.log("NIMO: startScan()")
         if centralManager == nil {
             centralManager = CBCentralManager(
@@ -1083,17 +1126,32 @@ class Nimo: NSObject, SGCManager {
 
         // Fast path: reconnect to the cached peripheral UUID.
         if connectByUUID() {
+            stopScan()
             return true
         }
 
-        centralManager!.scanForPeripherals(
-            withServices: nil,
-            options: [CBCentralManagerScanOptionAllowDuplicatesKey: false]
-        )
+        // NIMO's Companion service is GATT over BR/EDR. The main device must
+        // first be paired in Settings; it does not appear in a BLE-only scan.
+        discovery.start()
         return true
     }
 
+    private func onDeviceFound(_ peripheral: CBPeripheral, name: String, rssi: Int?) {
+        Bridge.log("NIMO: found Companion device: \(name)")
+        Bridge.sendDiscoveredDevice(DeviceTypes.NIMO, name, rssi: rssi)
+        guard DEVICE_SEARCH_ID != "NOT_SET", name == DEVICE_SEARCH_ID,
+              self.peripheral == nil else { return }
+        Bridge.log("NIMO: Connecting to \(name)")
+        stopScan()
+        lastDeviceName = name
+        lastDeviceUUID = peripheral.identifier.uuidString
+        self.peripheral = peripheral
+        peripheral.delegate = self
+        centralManager?.connect(peripheral, options: nil)
+    }
+
     private func connectByUUID() -> Bool {
+        guard peripheral == nil else { return false }
         guard DEVICE_SEARCH_ID != "NOT_SET", !DEVICE_SEARCH_ID.isEmpty else { return false }
         guard lastDeviceName == DEVICE_SEARCH_ID,
               let uuidString = lastDeviceUUID,
@@ -1255,6 +1313,9 @@ class Nimo: NSObject, SGCManager {
                 needsAck: false
             )
         )
+        // Optional setting: older firmware may reject it without preventing connection.
+        sendFrame(NimoFrameCodec.encodeFrame(cmd: NimoProtocol.CMD_SET_PARAMETER,
+                                             key: NimoProtocol.SET_SYSTEM_LANGUAGE, payload: Data([NimoProtocol.LANGUAGE_ENGLISH])))
         getBatteryStatus()
         requestVersionInfo()
 
@@ -1264,7 +1325,10 @@ class Nimo: NSObject, SGCManager {
         DeviceStore.shared.apply("glasses", "fullyBooted", true)
         DeviceStore.shared.apply("glasses", "connectionState", ConnTypes.CONNECTED)
         startTimers()
-        canvas.readiness(twsConnected && peerCompanionReady == true)
+        // The Launch ACK validates peer readiness without waiting for the first
+        // unsolicited heartbeat (which can arrive a minute after connection).
+        canvas.activate()
+        canvas.readiness(twsConnected && peerCompanionReady != false)
     }
 
     private func handshakeFailed() {
@@ -1299,7 +1363,8 @@ class Nimo: NSObject, SGCManager {
                 }
                 Bridge.log("NIMO: Attempting reconnection...")
                 await MainActor.run {
-                    self.isDisconnecting = false
+                    guard !self.isDisconnecting else { return }
+                    self.scanRequested = true
                     self.startScan()
                 }
                 return false
@@ -1332,6 +1397,7 @@ class Nimo: NSObject, SGCManager {
     private func handleRxPacket(_ packet: Data) {
         if packet.count >= 10, packet[8] == 7, [1, 3, 4].contains(packet[9]) {
             if let response = NimoCanvasCodec.response(packet) {
+                if response.key == 1 { Bridge.log("NIMO: canvas Launch response status=\(response.payload.first.map(Int.init) ?? -1)") }
                 canvas.response(key: response.key, payload: response.payload)
             }
             return
@@ -1365,9 +1431,9 @@ class Nimo: NSObject, SGCManager {
                 Bridge.log("NIMO: app state report appId=\(appId) phase=\(phase)")
                 switch phase {
                 case NimoProtocol.STATE_ENTER:
-                    if canvas.nativeApp(appId, entered: true) { canvasEncoder.invalidate() }
+                    canvas.nativeApp(appId, entered: true)
                 case NimoProtocol.STATE_EXIT:
-                    if canvas.nativeApp(appId, entered: false) { canvasEncoder.invalidate() }
+                    canvas.nativeApp(appId, entered: false)
                 default:
                     break
                 }
@@ -1397,7 +1463,7 @@ class Nimo: NSObject, SGCManager {
                 peerCompanionReady = v[9] != 0
                 onTwsState(Int(v[8]) >= 1)
                 if handshakeState == .ready {
-                    canvas.readiness(twsConnected && peerCompanionReady == true, confirmed: true)
+                    canvas.readiness(twsConnected && peerCompanionReady != false, confirmed: true)
                 }
             }
         case NimoProtocol.BUSINESS_BATTERY:
@@ -1420,7 +1486,7 @@ class Nimo: NSObject, SGCManager {
         if !connected, handshakeState == .ready {
             Bridge.log("NIMO: TWS service dropped mid-session (arm removed/off?)")
         }
-        if handshakeState == .ready { canvas.readiness(connected && peerCompanionReady == true) }
+        if handshakeState == .ready { canvas.readiness(connected && peerCompanionReady != false) }
     }
 
     private func handleInputEvent(_ code: Int) {
@@ -1456,6 +1522,9 @@ class Nimo: NSObject, SGCManager {
     }
 
     private func handleResponse(cmd: Int, key: Int, statusCode: Int, data: Data) {
+        if cmd == NimoProtocol.CMD_SET_PARAMETER, key == NimoProtocol.SET_SYSTEM_LANGUAGE {
+            Bridge.log("NIMO: English menu setting acknowledged=\(statusCode == 0) status=\(statusCode)")
+        }
         resolvePendingAck(cmd: cmd, key: key, success: statusCode == 0)
 
         guard cmd == NimoProtocol.CMD_GET_PARAMETER, statusCode == 0 else { return }
@@ -1543,7 +1612,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)
             }
         }
     }
@@ -1564,37 +1633,29 @@ extension Nimo: CBCentralManagerDelegate {
     }
 
     nonisolated func centralManager(
-        _ central: CBCentralManager,
+        _: CBCentralManager,
         didDiscover peripheral: CBPeripheral,
         advertisementData: [String: Any],
         rssi: NSNumber
     ) {
-        guard
-            let name = peripheral.name
-            ?? advertisementData[CBAdvertisementDataLocalNameKey] as? String
-        else { return }
+        let advertisedName = advertisementData[CBAdvertisementDataLocalNameKey] as? String
         let rssiValue = rssi.intValue
-
         DispatchQueue.main.async { [weak self] in
-            guard let self else { return }
-            guard self.isNimoMainDevice(name) else { return }
-
-            Bridge.sendDiscoveredDevice(DeviceTypes.NIMO, name, rssi: rssiValue)
-
-            guard self.DEVICE_SEARCH_ID != "NOT_SET" else { return }
-            guard name == self.DEVICE_SEARCH_ID else { return }
-            guard self.peripheral == nil else { return }
-
-            Bridge.log("NIMO: Connecting to \(name)")
-            self.stopScan()
-            self.lastDeviceName = name
-            self.lastDeviceUUID = peripheral.identifier.uuidString
-            self.peripheral = peripheral
-            peripheral.delegate = self
-            central.connect(peripheral, options: nil)
+            self?.discovery.receive(peripheral, advertisedName: advertisedName, rssi: rssiValue)
         }
     }
 
+    #if os(iOS)
+        nonisolated func centralManager(
+            _: CBCentralManager, connectionEventDidOccur event: CBConnectionEvent, for peripheral: CBPeripheral
+        ) {
+            guard event == .peerConnected else { return }
+            DispatchQueue.main.async { [weak self] in
+                self?.discovery.receive(peripheral)
+            }
+        }
+    #endif
+
     nonisolated func centralManager(_: CBCentralManager, didConnect peripheral: CBPeripheral) {
         DispatchQueue.main.async { [weak self] in
             guard let self else { return }

package/ios/Source/sgcs/NimoCanvasCoordinator.swift

@@ -21,6 +21,7 @@ final class NimoCanvasCoordinator {
     private let rejected: (Int) -> Void
     private let session = NimoCanvasSession()
     private var flight: Flight?
+    private var cancelRetry: (() -> Void)?
     private var cancelDeadline: (() -> Void)?
 
     init(schedule: @escaping NimoScheduler, writeCapacity: @escaping () -> Int,
@@ -35,23 +36,26 @@ final class NimoCanvasCoordinator {
         run(session.offer(bytes, scope: scope, force: force))
     }
 
+    func activate() {
+        run(session.activate())
+    }
+
     func readiness(_ value: Bool, confirmed: Bool = false) {
+        if !value { cancelRetry?(); cancelRetry = nil }
         run(session.readiness(value, confirmed: confirmed))
     }
 
     func exit() {
+        cancelRetry?(); cancelRetry = nil
         run(session.exit())
     }
 
-    /// An expected Exit report must not discard a newer host encode queued behind Exit.
-    func nativeApp(_ appId: Int, entered: Bool) -> Bool {
-        let takeover = (appId == NimoCanvasCodec.appId && !entered) || (appId != NimoCanvasCodec.appId && entered)
-        let expectedExit = appId == NimoCanvasCodec.appId && !entered && flight?.key == 3
+    func nativeApp(_ appId: Int, entered: Bool) {
         run(session.nativeApp(appId, entered: entered))
-        return takeover && !expectedExit
     }
 
     func disconnected() {
+        cancelRetry?(); cancelRetry = nil
         cancelDeadline?(); cancelDeadline = nil
         flight = nil
         session.disconnected()
@@ -72,6 +76,7 @@ final class NimoCanvasCoordinator {
         for action in actions {
             switch action {
             case let .send(key, frame, ticket):
+                cancelRetry?(); cancelRetry = nil
                 cancelDeadline?()
                 let current = Flight(key: key)
                 flight = current
@@ -93,7 +98,16 @@ final class NimoCanvasCoordinator {
                     disconnected(); reconnect("Canvas framing failed: \(error)")
                 }
             case let .reconnect(reason): disconnected(); reconnect(reason)
-            case let .rejected(status): rejected(status)
+            case let .rejected(status):
+                rejected(status)
+                if status == 7 {
+                    cancelRetry?()
+                    cancelRetry = schedule(1) { [weak self] in
+                        guard let self else { return }
+                        self.cancelRetry = nil
+                        self.run(self.session.retryNotReady())
+                    }
+                }
             }
         }
     }

package/ios/Source/sgcs/NimoCanvasSession.swift

@@ -15,12 +15,14 @@ final class NimoCanvasSession {
     }
 
     private var ready = false
+    private var transportReady = false
     private var active = false
     private var locked = false
     private var launchBlocked = false
     private var waitingReadiness = false
     private var observedNotReady = false
     private var readinessRetries = 0
+    private var probeRetries = 0
     private var exitRequested = false
     private var desired: Data?
     private var accepted: Data?
@@ -39,9 +41,27 @@ final class NimoCanvasSession {
         return pump()
     }
 
+    /// Enter a blank canvas unless a newer host scene survived the connection change.
+    func activate() -> [Action] {
+        if desired == nil { desired = Data([0, 0, 1]) }
+        exitRequested = false
+        return pump()
+    }
+
+    /// The firmware validates peer readiness on Launch. Only an explicit NOT_READY
+    /// permits a bounded retry; an ambiguous ACK still requires a new transport.
+    func retryNotReady() -> [Action] {
+        guard transportReady, waitingReadiness, desired != nil, probeRetries < 3 else { return [] }
+        probeRetries += 1
+        waitingReadiness = false
+        ready = true
+        return pump()
+    }
+
     /// Only a fresh heartbeat samples both TWS and peer Companion readiness.
     func readiness(_ value: Bool, confirmed: Bool = false) -> [Action] {
-        if !value { readinessRetries = 0 }
+        transportReady = value
+        if !value { readinessRetries = 0; probeRetries = 0 }
         if !value, flight != nil { return resetLink("Readiness lost during canvas command") }
         if waitingReadiness {
             if !value { observedNotReady = true }
@@ -58,8 +78,8 @@ final class NimoCanvasSession {
 
     /// Keep only the latest desired scene across a new transport generation.
     func disconnected() {
-        ready = false; active = false; locked = false; launchBlocked = false
-        waitingReadiness = false; observedNotReady = false; readinessRetries = 0
+        ready = false; transportReady = false; active = false; locked = false; launchBlocked = false
+        waitingReadiness = false; observedNotReady = false; readinessRetries = 0; probeRetries = 0
         accepted = nil; rejected = nil; flight = nil
         ticket &+= 1; forceRevision &+= 1
     }
@@ -69,16 +89,12 @@ final class NimoCanvasSession {
         return pump()
     }
 
+    /// Stock UI reports do not relinquish host ownership. Replay after the current ACK.
     func nativeApp(_ appId: Int, entered: Bool) -> [Action] {
         if (appId == NimoCanvasCodec.appId && !entered) || (appId != NimoCanvasCodec.appId && entered) {
-            if flight?.key == 3 {
-                active = false; accepted = nil
-                if appId != NimoCanvasCodec.appId, entered { desired = nil; rejected = nil; scope = nil }
-                return []
-            }
-            let ambiguous = flight != nil
-            desired = nil; accepted = nil; rejected = nil; active = false; exitRequested = false; scope = nil
-            if ambiguous { return resetLink("Native app transition interrupted canvas command") }
+            active = false
+            accepted = nil
+            return pump()
         }
         return []
     }
@@ -112,8 +128,8 @@ final class NimoCanvasSession {
             return [.rejected(status)] + pump()
         }
         switch key {
-        case 1: active = true
-        case 4: accepted = current.frame; rejected = nil; readinessRetries = 0
+        case 1: active = true; accepted = nil
+        case 4: accepted = current.frame; rejected = nil; readinessRetries = 0; probeRetries = 0
         case 3: active = false; accepted = nil; exitRequested = false
         default: break
         }
@@ -126,7 +142,7 @@ final class NimoCanvasSession {
     }
 
     private func resetLink(_ reason: String) -> [Action] {
-        ready = false; active = false; accepted = nil; flight = nil
+        ready = false; transportReady = false; active = false; accepted = nil; flight = nil
         ticket &+= 1; forceRevision &+= 1
         return [.reconnect(reason)]
     }

package/ios/Source/sgcs/NimoDiscovery.swift

@@ -0,0 +1,49 @@
+import Foundation
+
+/// Combines system-connected classic devices with incoming CoreBluetooth discoveries.
+/// Kept independent of the radio so discovery can be exercised without hardware.
+@MainActor
+final class NimoDiscovery<Peripheral> {
+    private(set) var active = false
+    private let register: () -> Void
+    private let connected: () -> [Peripheral]
+    private let scan: () -> Void
+    private let stop: () -> Void
+    private let name: (Peripheral) -> String?
+    private let found: (Peripheral, String, Int?) -> Void
+
+    init(register: @escaping () -> Void, connected: @escaping () -> [Peripheral],
+         scan: @escaping () -> Void, stop: @escaping () -> Void,
+         name: @escaping (Peripheral) -> String?, found: @escaping (Peripheral, String, Int?) -> Void)
+    {
+        self.register = register
+        self.connected = connected
+        self.scan = scan
+        self.stop = stop
+        self.name = name
+        self.found = found
+    }
+
+    func start() {
+        active = true
+        // Register first so pairing in Settings cannot race the connected snapshot.
+        register()
+        for peripheral in connected() {
+            receive(peripheral)
+        }
+        if active { scan() }
+    }
+
+    func cancel() {
+        active = false
+        stop()
+    }
+
+    func receive(_ peripheral: Peripheral, advertisedName: String? = nil, rssi: Int? = nil) {
+        guard active, let name = advertisedName ?? name(peripheral) else { return }
+        let lower = name.lowercased()
+        // The separate ANCS peripheral does not host the Companion data service.
+        guard lower.hasPrefix("nimo"), !lower.hasSuffix("_ble") else { return }
+        found(peripheral, name, rssi)
+    }
+}

package/ios/Source/status/DeviceStatus.swift

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