@mentra/bluetooth-sdk 3.2.0-dev.180 → 3.2.0-dev.187

package/ios/Source/sgcs/G2.swift

@@ -8,8 +8,8 @@
 
 import Combine
 import CoreBluetooth
-import Foundation
 import CoreGraphics
+import Foundation
 
 /// Keep a low-rate, non-audio EvenHub sensor stream active so iOS continues receiving BLE
 /// notifications while the Mentra App is backgrounded. The samples stay internal unless IMU was
@@ -890,7 +890,7 @@ private enum EvenAIProto {
 
 // MARK: - Notification Protobuf Builders (notification.proto, service ID 4)
 
-private enum NotificationProto {
+enum G2NotificationProto {
     /// NotificationDataPackage with commandId=NOTIFICATION_IOS (2), carrying
     /// `NotificationIOS { appID, displayName }`. We saw the glasses emit this
     /// inbound after "Hey Even, show notifications" with appID="com.burbn.instagram";
@@ -1714,8 +1714,13 @@ class G2: NSObject, SGCManager {
     // The pace replaces the gate's overflow protection (the original reason for gating). Any packet
     // CoreBluetooth still drops self-heals: text is re-sent (TextContainer.pendingSends) and image
     // fragments retry on their ACK (`awaitImageAck`).
-    private var leftWriteQueue: [Data] = []
-    private var rightWriteQueue: [Data] = []
+    private struct PendingWrite {
+        let data: Data
+        let notificationEpoch: Int?
+    }
+
+    private var leftWriteQueue: [PendingWrite] = []
+    private var rightWriteQueue: [PendingWrite] = []
     private var leftDraining = false
     private var rightDraining = false
     // Pace between consecutive packets (~G1's chunk pacing). Off any external callback, so the drain
@@ -1725,13 +1730,14 @@ class G2: NSObject, SGCManager {
     // making progress). Rate-limited. Prefixed "BGCAP:" so it's easy to grep/strip after validation.
     private var bgcapDepthLogAt: Double = 0
 
-    private func sendToGlasses(_ packets: [Data], left: Bool = false, right: Bool = true) {
+    private func sendToGlasses(_ packets: [Data], left: Bool = false, right: Bool = true, notificationEpoch: Int? = nil) {
+        let writes = packets.map { PendingWrite(data: $0, notificationEpoch: notificationEpoch) }
         if right {
-            rightWriteQueue.append(contentsOf: packets)
+            rightWriteQueue.append(contentsOf: writes)
             startDrain(right: true)
         }
         if left {
-            leftWriteQueue.append(contentsOf: packets)
+            leftWriteQueue.append(contentsOf: writes)
             startDrain(right: false)
         }
     }
@@ -1777,7 +1783,8 @@ class G2: NSObject, SGCManager {
                 }
             }
             let packet = right ? rightWriteQueue.removeFirst() : leftWriteQueue.removeFirst()
-            peripheral.writeValue(packet, for: char, type: .withoutResponse)
+            if let epoch = packet.notificationEpoch, epoch != notificationEpoch { continue }
+            peripheral.writeValue(packet.data, for: char, type: .withoutResponse)
             try? await Task.sleep(nanoseconds: writePaceNanos)
         }
     }
@@ -2659,7 +2666,7 @@ class G2: NSObject, SGCManager {
         //     "G2: sendImageData(\(containerName)) - \(fragmentCount) fragments, \(bmpData.count) bytes"
         // )
 
-        for attempt in 1...IMG_MAX_ATTEMPTS {
+        for _ in 1 ... IMG_MAX_ATTEMPTS {
             // One session id per WHOLE image transfer (per attempt). The glasses key their
             // reassembly buffer on MapSessionId, so every fragment of this image must reuse the
             // same session id with an incrementing MapFragmentIndex; the per-fragment ACK is
@@ -3659,6 +3666,8 @@ class G2: NSObject, SGCManager {
     func disconnect() {
         Bridge.log("G2: disconnect()")
         isDisconnecting = true
+        notificationEpoch += 1
+        notificationControlMagic = nil
         clearDisplay()
         cancelPairingTimeout()
         stopHeartbeats()
@@ -3807,6 +3816,88 @@ class G2: NSObject, SGCManager {
         sendEvenAICommand(payload)
     }
 
+    private var notificationConfig = NativeNotificationConfig()
+    private var notificationEpoch = 0
+    private var notificationControlMagic: Int32?
+    private var notificationError = ""
+
+    private var notificationAuthorization: String {
+        #if os(macOS)
+            return "unknown"
+        #else
+            let connected = [leftPeripheral, rightPeripheral].compactMap { $0 }.filter { $0.state == .connected }
+            guard !connected.isEmpty else { return "unknown" }
+            return connected.contains { $0.ancsAuthorized } ? "authorized" : "not_authorized"
+        #endif
+    }
+
+    func getNativeNotificationStatus() -> NativeNotificationStatus {
+        #if os(macOS)
+            return .unavailable
+        #else
+        let ready = DeviceStore.shared.get("glasses", "fullyBooted") as? Bool ?? false
+        return NativeNotificationStatus(
+            supported: true, source: "ancs", authorization: notificationAuthorization,
+            state: !ready ? "unavailable" : !notificationError.isEmpty ? "failed" : notificationConfig.enabled ? "submitted" : "disabled",
+            config: notificationConfig, error: notificationError
+        )
+        #endif
+    }
+
+    private func publishNotificationStatus() {
+        Bridge.sendTypedMessage("native_notification_status", body: getNativeNotificationStatus().dictionary)
+    }
+
+    func configureNativeNotifications(_ config: NativeNotificationConfig) throws {
+        #if os(macOS)
+            throw NativeNotificationError.unsupported
+        #else
+        try config.validateForAncs()
+        notificationConfig = config
+        applyNotificationControls()
+        #endif
+    }
+
+    private func applyNotificationControls() {
+        #if os(macOS)
+            publishNotificationStatus()
+            return
+        #endif
+        notificationControlMagic = nil
+        notificationEpoch += 1 // Discard unsent controls from the previous settings/connection.
+        notificationError = ""
+        guard DeviceStore.shared.get("glasses", "fullyBooted") as? Bool == true else {
+            publishNotificationStatus()
+            return
+        }
+        let config = notificationConfig
+        // Never enable ANCS presentation before the accessory is authorized. Disabling
+        // still reaches firmware after permission revocation.
+        let enabled = config.enabled && notificationAuthorization == "authorized"
+        let magic = sendManager.nextMagicRandom()
+        notificationControlMagic = magic
+        let payload = G2NotificationProto.notificationCtrl(
+            magicRandom: magic, notifEnable: enabled ? 1 : 0,
+            autoDispEnable: config.autoDisplay ? 1 : 0,
+            dispTime: Int32(config.durationSeconds), avoidDisturbEnable: config.doNotDisturb ? 1 : 0
+        )
+        sendToGlasses(sendManager.buildPackets(serviceId: ServiceID.notification.rawValue, payload: payload, reserveFlag: true), notificationEpoch: notificationEpoch)
+        // Preserve the firmware's existing iOS app whitelist. Android package filters
+        // cannot safely be applied to the ANCS stream or translated to bundle IDs.
+        publishNotificationStatus()
+    }
+
+    private var notificationConnectionOptions: [String: Any] {
+        var options: [String: Any] = [
+            CBConnectPeripheralOptionNotifyOnConnectionKey: true,
+            CBConnectPeripheralOptionNotifyOnDisconnectionKey: true,
+        ]
+        #if !os(macOS)
+            options[CBConnectPeripheralOptionRequiresANCS] = true
+        #endif
+        return options
+    }
+
     /// Open the on-glasses notification panel — same effect as the user saying
     /// "Hey Even, show notifications". Replicates the official-app voice flow:
     ///   1. CTRL{status=ENTER}     — puts glasses in AI session
@@ -4102,10 +4193,7 @@ class G2: NSObject, SGCManager {
                     device.discoverServices([G2BLE.SERVICE_UUID])
                     centralManager!.connect(
                         leftPeripheral!,
-                        options: [
-                            CBConnectPeripheralOptionNotifyOnConnectionKey: true,
-                            CBConnectPeripheralOptionNotifyOnDisconnectionKey: true,
-                        ]
+                        options: notificationConnectionOptions
                     )
                 } else if name.contains("_R_") && serialNumber.contains(DEVICE_SEARCH_ID) {
                     rightPeripheral = device
@@ -4113,10 +4201,7 @@ class G2: NSObject, SGCManager {
                     device.discoverServices([G2BLE.SERVICE_UUID])
                     centralManager!.connect(
                         rightPeripheral!,
-                        options: [
-                            CBConnectPeripheralOptionNotifyOnConnectionKey: true,
-                            CBConnectPeripheralOptionNotifyOnDisconnectionKey: true,
-                        ]
+                        options: notificationConnectionOptions
                     )
                 }
                 // we can't emit the serial number here unfortunately:
@@ -4180,8 +4265,8 @@ class G2: NSObject, SGCManager {
         rightPeripheral = right
         left.delegate = self
         right.delegate = self
-        centralManager?.connect(left, options: nil)
-        centralManager?.connect(right, options: nil)
+        centralManager?.connect(left, options: notificationConnectionOptions)
+        centralManager?.connect(right, options: notificationConnectionOptions)
         return true
     }
 
@@ -4231,6 +4316,7 @@ class G2: NSObject, SGCManager {
     // MARK: - Incoming Data Handling
 
     private func handleNotifyData(_ data: Data, from peripheral: CBPeripheral) async {
+        guard peripheral === leftPeripheral || peripheral === rightPeripheral else { return }
         // Distinguish left vs right peripheral so multi-packet reassembly doesn't collide
         let sourceKey = peripheral === leftPeripheral ? "L" : "R"
         guard let result = receiveManager.handlePacket(data, sourceKey: sourceKey) else { return }
@@ -4286,6 +4372,16 @@ class G2: NSObject, SGCManager {
         let fields = reader.parseFields()
         let cmd = fields[1] as? Int32 ?? 0
 
+        if cmd == 161, let response = fields[5] as? Data {
+            var responseReader = ProtobufReader(response)
+            let values = responseReader.parseFields()
+            if fields[2] as? Int32 == notificationControlMagic,
+               values[1] as? Int32 == 1, let code = values[2] as? Int32, code != 0
+            {
+                notificationError = "configuration_rejected_\(values[2] as? Int32 ?? -1)"
+                publishNotificationStatus()
+            }
+        }
         var detail = ""
         if let iosData = fields[4] as? Data {
             var ios = ProtobufReader(iosData)
@@ -4525,6 +4621,7 @@ class G2: NSObject, SGCManager {
         }
         if !isFullyBooted {
             DeviceStore.shared.apply("glasses", "fullyBooted", true)
+            applyNotificationControls()
         }
     }
 
@@ -5157,14 +5254,14 @@ extension G2: CBCentralManagerDelegate {
                 if self.leftPeripheral == nil {
                     self.leftPeripheral = peripheral
                     peripheral.delegate = self
-                    central.connect(peripheral, options: nil)
+                    central.connect(peripheral, options: self.notificationConnectionOptions)
                     // Bridge.log("G2: Connecting to LEFT: \(name)")
                 }
             } else if name.contains("_R_") {
                 if self.rightPeripheral == nil {
                     self.rightPeripheral = peripheral
                     peripheral.delegate = self
-                    central.connect(peripheral, options: nil)
+                    central.connect(peripheral, options: self.notificationConnectionOptions)
                     // Bridge.log("G2: Connecting to RIGHT: \(name)")
                 }
             }
@@ -5177,6 +5274,15 @@ extension G2: CBCentralManagerDelegate {
         }
     }
 
+    #if !os(macOS)
+        nonisolated func centralManager(_: CBCentralManager, didUpdateANCSAuthorizationFor peripheral: CBPeripheral) {
+            DispatchQueue.main.async { [weak self] in
+                guard let self, peripheral === self.leftPeripheral || peripheral === self.rightPeripheral else { return }
+                self.applyNotificationControls()
+            }
+        }
+    #endif
+
     nonisolated func centralManager(_: CBCentralManager, didConnect peripheral: CBPeripheral) {
         DispatchQueue.main.async { [weak self] in
             guard let self = self else { return }
@@ -5209,6 +5315,9 @@ extension G2: CBCentralManagerDelegate {
             let side = peripheral === self.leftPeripheral ? "LEFT" : "RIGHT"
             Bridge.log("G2: Disconnected \(side): \(error?.localizedDescription ?? "clean")")
 
+            guard peripheral === self.leftPeripheral || peripheral === self.rightPeripheral else { return }
+            self.notificationEpoch += 1
+            self.notificationControlMagic = nil
             // Only reconnect if not intentionally disconnecting
             if self.isDisconnecting { return }
 
@@ -5233,6 +5342,7 @@ extension G2: CBCentralManagerDelegate {
             self.dashboardOpening = false
             DeviceStore.shared.apply("glasses", "connected", false)
             DeviceStore.shared.apply("glasses", "fullyBooted", false)
+            self.publishNotificationStatus()
 
             // Start persistent reconnection loop (every 30s, unlimited attempts)
             self.startReconnectionTimer()

package/ios/Source/sgcs/SGCManager.swift

@@ -145,6 +145,14 @@ protocol SGCManager {
 
     func showNotificationsPanel() async
 
+    /// Push a phone notification into the glasses' own notification centre.
+    ///
+    /// Android/G2 only in practice — iOS glasses read notifications over ANCS. Declared for
+    /// parity so the shared TypeScript module type is callable on both platforms.
+    func sendPhoneNotification(_ notification: [String: Any]) throws
+    func configureNativeNotifications(_ config: NativeNotificationConfig) throws
+    func getNativeNotificationStatus() -> NativeNotificationStatus
+
     // MARK: - Calendar Events
 
     func sendCalendarEvents(_ events: [[String: Any]])
@@ -357,6 +365,20 @@ extension SGCManager {
 
     func showNotificationsPanel() async {}
 
+    // MARK: - Native notification centre (default no-op — Android/G2 only; iOS uses ANCS)
+
+    func sendPhoneNotification(_: [String: Any]) throws {
+        throw NativeNotificationError.unsupported
+    }
+
+    func configureNativeNotifications(_: NativeNotificationConfig) throws {
+        throw NativeNotificationError.unsupported
+    }
+
+    func getNativeNotificationStatus() -> NativeNotificationStatus {
+        .unavailable
+    }
+
     // MARK: - IMU (default no-op — only G2 streams accelerometer data)
 
     func setImuEnabled(_: Bool) async {

package/ios/Tests/ConnectedDeviceMatcherTests.swift

@@ -0,0 +1,27 @@
+import Foundation
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class ConnectedDeviceMatcherTests: XCTestCase {
+    func testSavedIdentityTakesPrecedenceOverName() {
+        let saved = Device(model: .g1, name: "Saved glasses", identifier: "ABC")
+        XCTAssertTrue(ConnectedDeviceMatcher.matches(model: .g1, defaultDevice: saved, name: nil, identifier: "abc"))
+        XCTAssertFalse(ConnectedDeviceMatcher.matches(model: .g1, defaultDevice: saved, name: saved.name, identifier: "OTHER"))
+        XCTAssertTrue(ConnectedDeviceMatcher.matches(model: .g1, defaultDevice: saved, name: saved.name, identifier: nil))
+        XCTAssertFalse(ConnectedDeviceMatcher.matches(model: .g2, defaultDevice: saved, name: saved.name, identifier: "ABC"))
+    }
+
+    func testKnownNamesAreOnlyHintsForTheirModel() {
+        XCTAssertTrue(ConnectedDeviceMatcher.matches(model: .mentraLive, defaultDevice: nil, name: "MENTRA_LIVE_BLE_123", identifier: nil))
+        XCTAssertTrue(ConnectedDeviceMatcher.matches(model: .mentraNex, defaultDevice: nil, name: "Nex1-123", identifier: nil))
+        XCTAssertFalse(ConnectedDeviceMatcher.matches(model: .g1, defaultDevice: nil, name: "MENTRA_LIVE_BLE_123", identifier: nil))
+        XCTAssertFalse(ConnectedDeviceMatcher.matches(model: .simulated, defaultDevice: nil, name: "Nex1-123", identifier: nil))
+        XCTAssertFalse(ConnectedDeviceMatcher.matches(model: .mentraLive, defaultDevice: nil, name: "Headphones", identifier: nil))
+        XCTAssertFalse(ConnectedDeviceMatcher.matches(model: .g1, defaultDevice: Device(model: .g1, name: ""), name: "", identifier: ""))
+    }
+
+    func testUnsupportedModelsDoNotQueryCoreBluetooth() {
+        XCTAssertTrue(ConnectedDeviceMatcher.serviceUUIDs(for: .simulated).isEmpty)
+        XCTAssertFalse(ConnectedDeviceMatcher.serviceUUIDs(for: .mentraLive).isEmpty)
+    }
+}

package/ios/Tests/NativeNotificationTests.swift

@@ -0,0 +1,20 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class NativeNotificationTests: XCTestCase {
+    func testDisableIsExplicitAndQuietModeDoesNotEnablePopups() {
+        let bytes = G2NotificationProto.notificationCtrl(magicRandom: 7, notifEnable: 0, autoDispEnable: 0, dispTime: 10, avoidDisturbEnable: 1)
+        XCTAssertEqual(bytes, Data([0x08, 1, 0x10, 7, 0x1A, 8, 0x08, 0, 0x10, 0, 0x18, 10, 0x28, 1]))
+    }
+
+    func testConfigRejectsInvalidDurationBeforeEncoding() {
+        XCTAssertThrowsError(try NativeNotificationConfig(durationSeconds: 0).validate())
+        XCTAssertThrowsError(try NativeNotificationConfig(durationSeconds: 31).validate())
+        XCTAssertNoThrow(try NativeNotificationConfig(durationSeconds: 30).validate())
+    }
+
+    func testAncsRejectsPhoneSideFiltering() {
+        XCTAssertThrowsError(try NativeNotificationConfig(blockedApps: ["com.example"]).validateForAncs())
+        XCTAssertNoThrow(try NativeNotificationConfig(blockedApps: []).validateForAncs())
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "3.2.0-dev.180",
+  "version": "3.2.0-dev.187",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",

package/src/BluetoothSdk.types.ts

@@ -924,6 +924,8 @@ export type BluetoothSdkModuleEvents = {
   speaking_status: (event: SpeakingStatusEvent) => void
   battery_status: (event: BatteryStatusEvent) => void
   local_transcription: (event: LocalTranscriptionEvent) => void
+  native_notification_status: (event: NativeNotificationStatus) => void
+  native_notification_delivery: (event: NativeNotificationDelivery) => void
   phone_notification: (event: PhoneNotificationEvent) => void
   phone_notification_dismissed: (event: PhoneNotificationDismissedEvent) => void
   wifi_status_change: (event: WifiStatusChangeEvent) => void
@@ -1004,6 +1006,54 @@ export interface PhoneNotificationDismissedEvent {
   timestamp: number
 }
 
+/**
+ * Outbound payload for `sendPhoneNotification` — a notification pushed INTO the glasses' own
+ * notification centre. The inverse of {@link PhoneNotificationEvent}, which reports
+ * notifications the glasses relayed TO the phone (iOS/ANCS). Drivers map these keys onto
+ * whatever their firmware expects.
+ */
+export interface NativeNotificationConfig {
+  enabled: boolean
+  autoDisplay: boolean
+  durationSeconds: number
+  doNotDisturb: boolean
+  /** Android package names. iOS rejects nonempty lists; its ANCS filter is firmware-owned. */
+  blockedApps: string[]
+}
+
+export interface NativeNotificationStatus {
+  supported: boolean
+  source: "phone" | "ancs" | "unsupported"
+  authorization: "system" | "authorized" | "not_authorized" | "unknown"
+  /** `submitted` is not a firmware-confirmed acknowledgement. */
+  state: "unavailable" | "disabled" | "configuring" | "submitted" | "needs_reconnect" | "failed"
+  config: NativeNotificationConfig
+  error: string
+}
+
+export interface NativeNotificationDelivery {
+  notificationId: string
+  status: "delivered" | "failed" | "cancelled" | "dropped"
+  reason: string
+}
+
+export interface NativePhoneNotification {
+  /** Stable id from the phone's notification listener; parsed to an int where firmware needs one. */
+  notificationId: string
+  /** Reverse-DNS package id of the originating app. */
+  packageName: string
+  /** Human app name (e.g. "Messages"). */
+  appName: string
+  title: string
+  /** Android `android.subText`. Empty when the listener didn't capture one. */
+  subtitle: string
+  body: string
+  /** Unix ms post time. */
+  timestampMs: number
+  /** Posted or updated. Removal is not supported by the verified protocol. */
+  action: 0
+}
+
 export type PublicGlassesStatus = Omit<
   GlassesStatus,
   "otaUpdateAvailable" | "otaProgress" | "otaInProgress" | "otaVersionUrl"
@@ -1024,6 +1074,8 @@ export type PublicBluetoothStatus = Pick<
 >
 
 export type BluetoothSdkEventMap = {
+  native_notification_status: NativeNotificationStatus
+  native_notification_delivery: NativeNotificationDelivery
   log: LogEvent
   device_discovered: Device
   default_device_changed: {device?: Device}
@@ -1087,6 +1139,8 @@ export type BluetoothSdkSubscription = {
 export type BluetoothSdkEvent = BluetoothSdkEventMap[BluetoothSdkEventName]
 
 export interface BluetoothSdkPublicModule {
+  configureNativeNotifications(config: NativeNotificationConfig): Promise<void>
+  getNativeNotificationStatus(): Promise<NativeNotificationStatus>
   addListener<EventName extends BluetoothSdkEventName>(
     eventName: EventName,
     listener: BluetoothSdkEventListener<EventName>,
@@ -1435,6 +1489,12 @@ export interface ConnectOptions {
 
 export type ScanResultsCallback = (devices: Device[]) => void
 
+/** Advisory for an empty scan. System connection state does not identify an owning app. */
+export interface ScanDiagnostic {
+  code: string
+  message: string
+}
+
 export interface ScanOptions {
   model: DeviceModel
   /** Defaults to 15000. */
@@ -1443,6 +1503,8 @@ export interface ScanOptions {
   timeout?: number
   /** Called every time the discovered device list changes during the scan. */
   onResults?: ScanResultsCallback
+  /** Optional non-fatal hint before an empty scan resolves, on Android and iOS. */
+  onDiagnostic?: (diagnostic: ScanDiagnostic) => void
 }
 
 export type ScanModelOptions = Omit<ScanOptions, "model">

package/src/_private/BluetoothSdkModule.ts

@@ -1,3 +1,4 @@
+import {createScanSession} from "./scanSession"
 import {NativeModule, requireNativeModule} from "expo"
 
 import {
@@ -26,6 +27,9 @@ import {
   GalleryStatusEvent,
   HotspotStatusChangeEvent,
   MicPreference,
+  NativePhoneNotification,
+  NativeNotificationConfig,
+  NativeNotificationStatus,
   ObservableStoreCategory,
   OtaQueryResult,
   OtaStartAckEvent,
@@ -35,6 +39,7 @@ import {
   RgbLedAction,
   RgbLedColor,
   RgbLedControlSuccessResponseEvent,
+  ScanDiagnostic,
   ScanModelOptions,
   ScanOptions,
   SettingsAckSuccessEvent,
@@ -85,6 +90,7 @@ declare class BluetoothSdkNativeModule extends NativeModule<BluetoothSdkModuleEv
   connectDefaultWithOptions(options: Required<ConnectOptions>): Promise<void>
   setDefaultDevice(device: Device | null): Promise<void>
   clearDefaultDevice(): Promise<void>
+  getScanDiagnostic?: (model: DeviceModel) => Promise<ScanDiagnostic | null>
   startScan(model: DeviceModel): Promise<void>
   stopScan(): Promise<void>
   scan(options: ScanOptions): Promise<Device[]>
@@ -166,7 +172,13 @@ declare class BluetoothSdkNativeModule extends NativeModule<BluetoothSdkModuleEv
   startAr99OtaFromFile(path: string): Promise<boolean>
   cancelAr99Ota(): Promise<void>
   sendAr99FactoryReset(): Promise<void>
-  buildAr99OtaSignature(secret: string, appName: string, currentVersion: string, serialNumber: string, nonce: string): string
+  buildAr99OtaSignature(
+    secret: string,
+    appName: string,
+    currentVersion: string,
+    serialNumber: string,
+    nonce: string,
+  ): string
 
   // Version Info Commands
   requestVersionInfo(): Promise<VersionInfoResult>
@@ -255,6 +267,11 @@ declare class BluetoothSdkNativeModule extends NativeModule<BluetoothSdkModuleEv
     speed: number,
   ): Promise<boolean>
 
+  /** Android G2 content upload. iOS receives ANCS directly and rejects uploads. */
+  sendPhoneNotification(notification: NativePhoneNotification): Promise<void>
+  configureNativeNotifications(config: NativeNotificationConfig): Promise<void>
+  getNativeNotificationStatus(): Promise<NativeNotificationStatus>
+
   // Helper methods for type-safe observable store access
   updateGlasses(values: Partial<GlassesStatus>): Promise<void>
   updateBluetoothSettings(values: BluetoothSettingsUpdate): Promise<void>
@@ -581,65 +598,38 @@ NativeBluetoothSdkModule.connect = function (device: Device, options?: ConnectOp
   return this.connectWithOptions(device, {...DEFAULT_CONNECT_OPTIONS, ...options})
 }
 
+const nativeStopScan = NativeBluetoothSdkModule.stopScan.bind(NativeBluetoothSdkModule)
+const activeScanCancellations = new Set<() => Promise<void>>()
+NativeBluetoothSdkModule.stopScan = async function () {
+  if (activeScanCancellations.size === 0) return nativeStopScan()
+  await Promise.all([...activeScanCancellations].map(cancel => cancel()))
+}
+
 NativeBluetoothSdkModule.scan = async function (modelOrOptions: DeviceModel | ScanOptions, options?: ScanModelOptions) {
+  if (activeScanCancellations.size > 0) await this.stopScan()
   const scanOptions = normalizeScanArgs(modelOrOptions, options)
   const timeoutMs = normalizeTimeoutMs(scanOptions.timeoutMs ?? scanOptions.timeout, DEFAULT_SCAN_TIMEOUT_MS)
-  let latestResults: Device[] = []
-
-  return new Promise<Device[]>((resolve, reject) => {
-    let timeout: ReturnType<typeof setTimeout> | null = null
-    let removeBluetoothListener = () => {}
-    let settled = false
-    let scanStarted = false
-
-    const emitResults = (devices: Device[]) => {
-      latestResults = devices
-      scanOptions.onResults?.([...devices])
-    }
-
-    const cleanup = () => {
-      if (timeout) {
-        clearTimeout(timeout)
-      }
-      removeBluetoothListener()
-      if (scanStarted) {
-        void Promise.resolve(this.stopScan()).catch(() => undefined)
-      }
-    }
-
-    const settle = (error?: Error) => {
-      if (settled) {
-        return
-      }
-      settled = true
-      cleanup()
-      if (error) {
-        reject(error)
-      } else {
-        resolve([...latestResults])
-      }
-    }
-
-    const handleBluetoothStatus = (status: Partial<BluetoothStatus>) => {
-      if (!Array.isArray(status.searchResults)) {
-        return
-      }
-      emitResults(searchResultsForModel(status, scanOptions.model))
-    }
-
-    removeBluetoothListener = this.onBluetoothStatus(handleBluetoothStatus)
-    emitResults([])
-
-    timeout = setTimeout(() => settle(), timeoutMs)
-
-    Promise.resolve(this.startScan(scanOptions.model))
-      .then(() => {
-        scanStarted = true
-        return this.getBluetoothStatus()
-      })
-      .then(handleBluetoothStatus)
-      .catch((error) => settle(error instanceof Error ? error : new Error(String(error))))
-  })
+  const session = createScanSession(
+    {
+      start: (model) => this.startScan(model),
+      stop: nativeStopScan,
+      subscribe: (onResults) =>
+        this.onBluetoothStatus((status) => {
+          if (Array.isArray(status.searchResults)) onResults(searchResultsForModel(status, scanOptions.model))
+        }),
+      getResults: async () => searchResultsForModel(await this.getBluetoothStatus(), scanOptions.model),
+      // Older native binaries simply omit diagnostics until the host is rebuilt.
+      getDiagnostic:
+        typeof this.getScanDiagnostic === "function" ? () => this.getScanDiagnostic!(scanOptions.model) : undefined,
+    },
+    {...scanOptions, timeoutMs},
+  )
+  activeScanCancellations.add(session.cancel)
+  try {
+    return await session.result
+  } finally {
+    activeScanCancellations.delete(session.cancel)
+  }
 }
 
 const nativeRequestPhoto = NativeBluetoothSdkModule.requestPhoto.bind(NativeBluetoothSdkModule)