@mentra/bluetooth-sdk 3.2.1-dev.314 → 3.3.0-beta.942

package/ios/Tests/BluetoothSdkUsageTrackerTests.swift

@@ -0,0 +1,296 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class BluetoothSdkUsageTrackerTests: XCTestCase {
+    private var tracker = BluetoothSdkUsageTracker()
+
+    func testApiPhotoReportsItsRequestShapeLatencyAndOutcome() {
+        let ok = tracker.photoSettled(
+            size: "medium", mode: "photo", compress: "none", save: true, transferMethod: "auto",
+            latencyMs: 812, fileSizeBytes: 204_800, errorCode: nil
+        )
+        XCTAssertEqual(ok.name, "bluetooth_sdk_photo_taken")
+        XCTAssertEqual(ok.properties["trigger"] as? String, "api")
+        XCTAssertEqual(ok.properties["success"] as? Bool, true)
+        XCTAssertEqual(ok.properties["latency_ms"] as? Int64, 812)
+        XCTAssertEqual(ok.properties["photo_size"] as? String, "medium")
+        XCTAssertEqual(ok.properties["save_to_gallery"] as? Bool, true)
+        XCTAssertEqual(ok.properties["transfer_method"] as? String, "auto")
+        XCTAssertEqual(ok.properties["file_size_bytes"] as? Int64, 204_800)
+        XCTAssertNil(ok.properties["error_code"])
+
+        let failed = tracker.photoSettled(
+            size: "max", mode: "photo", compress: "none", save: false, transferMethod: "ble",
+            latencyMs: 30000, fileSizeBytes: nil, errorCode: "request_timeout"
+        )
+        XCTAssertEqual(failed.properties["success"] as? Bool, false)
+        XCTAssertEqual(failed.properties["error_code"] as? String, "request_timeout")
+        XCTAssertNil(failed.properties["file_size_bytes"])
+    }
+
+    func testFailedButtonPhotoIsReportedAsButtonTrigger() {
+        let event = tracker.buttonPhotoFailed(errorCode: "CAMERA_BUSY")
+        XCTAssertEqual(event.properties["trigger"] as? String, "button")
+        XCTAssertEqual(event.properties["success"] as? Bool, false)
+        XCTAssertEqual(event.properties["error_code"] as? String, "CAMERA_BUSY")
+        XCTAssertEqual(tracker.buttonPhotoFailed(errorCode: nil).properties["error_code"] as? String, "photo_request_failed")
+    }
+
+    func testApiRecordingReportsLengthParametersAndAppStopOnce() throws {
+        tracker.videoRequested(requestId: "rec-1", width: 1920, height: 1080, fps: 30, save: true, maxDurationMinutes: 0)
+        XCTAssertNil(tracker.videoStatus(requestId: "rec-1", status: "recording_started", success: true, nowMs: 1000))
+        // A duplicate start does not move the start time.
+        XCTAssertNil(tracker.videoStatus(requestId: "rec-1", status: "recording_started", success: true, nowMs: 2000))
+        tracker.videoStopRequested(requestId: "rec-1")
+
+        let stopped = try XCTUnwrap(tracker.videoStatus(requestId: "rec-1", status: "recording_stopped", success: true, nowMs: 61000))
+        XCTAssertEqual(stopped.name, "bluetooth_sdk_video_recorded")
+        XCTAssertEqual(stopped.properties["trigger"] as? String, "api")
+        XCTAssertEqual(stopped.properties["success"] as? Bool, true)
+        XCTAssertEqual(stopped.properties["duration_ms"] as? Int64, 60000)
+        XCTAssertEqual(stopped.properties["width"] as? Int, 1920)
+        XCTAssertEqual(stopped.properties["fps"] as? Int, 30)
+        XCTAssertEqual(stopped.properties["save_to_gallery"] as? Bool, true)
+        XCTAssertEqual(stopped.properties["stopped_by_app"] as? Bool, true)
+        XCTAssertNil(stopped.properties["max_duration_minutes"])
+
+        XCTAssertNil(tracker.videoStatus(requestId: "rec-1", status: "recording_stopped", success: true, nowMs: 62000))
+    }
+
+    func testButtonRecordingIsReportedWithButtonTriggerAndNoAppStop() throws {
+        let id = "local_video_1728000000_ab12"
+        _ = tracker.videoStatus(requestId: id, status: "recording_started", success: true, nowMs: 0)
+        let stopped = try XCTUnwrap(tracker.videoStatus(requestId: id, status: "recording_stopped", success: true, nowMs: 5000))
+        XCTAssertEqual(stopped.properties["trigger"] as? String, "button")
+        XCTAssertEqual(stopped.properties["duration_ms"] as? Int64, 5000)
+        XCTAssertEqual(stopped.properties["stopped_by_app"] as? Bool, false)
+    }
+
+    func testRecordingFailureIsReportedButNotRecordingIsNotARecording() throws {
+        tracker.videoRequested(requestId: "rec-2", width: 0, height: 0, fps: 0, save: false, maxDurationMinutes: 5)
+        let failed = try XCTUnwrap(tracker.videoStatus(requestId: "rec-2", status: "battery_low", success: false, nowMs: 0))
+        XCTAssertEqual(failed.properties["success"] as? Bool, false)
+        XCTAssertEqual(failed.properties["error_code"] as? String, "battery_low")
+        XCTAssertEqual(failed.properties["max_duration_minutes"] as? Int, 5)
+        XCTAssertNil(failed.properties["duration_ms"])
+        XCTAssertNil(failed.properties["width"])
+
+        XCTAssertNil(tracker.videoStatus(requestId: "rec-3", status: "not_recording", success: false, nowMs: 0))
+        XCTAssertNil(tracker.videoStatus(requestId: "", status: "recording_stopped", success: true, nowMs: 0))
+    }
+
+    func testStreamIsReportedAtStartAndOnceAtItsTerminalStatus() throws {
+        XCTAssertNil(tracker.streamRequested(streamId: "s1", streamUrl: "rtmps://live.example.com/app/secret-key", nowMs: 6600))
+        // The first live status can arrive before startStream returns.
+        XCTAssertNil(stream("streaming", nowMs: 10000))
+        let started = tracker.streamStartSettled(
+            streamUrl: "rtmps://live.example.com/app/secret-key",
+            width: 1280,
+            height: 720,
+            fps: 30,
+            bitrate: 2_000_000,
+            captureAudio: true,
+            glassesNetwork: "wifi",
+            latencyMs: 3400,
+            errorCode: nil
+        )
+        XCTAssertEqual(started.name, "bluetooth_sdk_stream_started")
+        XCTAssertEqual(started.properties["success"] as? Bool, true)
+        XCTAssertEqual(started.properties["protocol"] as? String, "rtmp")
+        XCTAssertEqual(started.properties["glasses_network"] as? String, "wifi")
+        XCTAssertFalse(started.properties.values.contains { "\($0)".contains("secret-key") })
+
+        XCTAssertNil(stream("reconnecting", reconnectAttempt: 1, nowMs: 20000))
+        XCTAssertNil(stream("reconnected", reconnectAttempt: 2, nowMs: 21000))
+        XCTAssertNil(stream("streaming", bitrate: 1_800_000, droppedFrames: 12, nowMs: 30000))
+        // Statuses for another stream id do not touch this one.
+        XCTAssertNil(tracker.streamStatus(
+            streamId: "other", state: "stopped", terminal: true, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: nil, nowMs: 31000
+        ))
+        tracker.streamStopRequested()
+
+        let ended = try XCTUnwrap(stream("stopped", terminal: true, nowMs: 70000))
+        XCTAssertEqual(ended.name, "bluetooth_sdk_stream_ended")
+        XCTAssertEqual(ended.properties["protocol"] as? String, "rtmp")
+        XCTAssertEqual(ended.properties["duration_ms"] as? Int64, 60000)
+        XCTAssertEqual(ended.properties["end_state"] as? String, "stopped")
+        XCTAssertEqual(ended.properties["stopped_by_app"] as? Bool, true)
+        XCTAssertEqual(ended.properties["reconnect_attempts"] as? Int, 2)
+        XCTAssertEqual(ended.properties["bitrate"] as? Int64, 1_800_000)
+        XCTAssertEqual(ended.properties["dropped_frames"] as? Int64, 12)
+
+        XCTAssertNil(stream("stopped", terminal: true, nowMs: 71000))
+    }
+
+    func testStreamThatEndsRightAfterGoingLiveIsStillReported() throws {
+        _ = tracker.streamRequested(streamId: "s1", streamUrl: "rtmp://host/app", nowMs: 0)
+        XCTAssertNil(stream("streaming", nowMs: 1000))
+        let ended = try XCTUnwrap(stream("error", terminal: true, nowMs: 1500))
+        XCTAssertEqual(ended.properties["duration_ms"] as? Int64, 500)
+        XCTAssertEqual(ended.properties["end_state"] as? String, "error")
+    }
+
+    func testNewStartReportsTheLiveStreamItReplaces() throws {
+        _ = tracker.streamRequested(streamId: "s1", streamUrl: "rtmp://host/app", nowMs: 0)
+        _ = stream("streaming", nowMs: 1000)
+        let replaced = try XCTUnwrap(tracker.streamRequested(streamId: "s2", streamUrl: "srt://host:9000", nowMs: 11000))
+        XCTAssertEqual(replaced.name, "bluetooth_sdk_stream_ended")
+        XCTAssertEqual(replaced.properties["protocol"] as? String, "rtmp")
+        XCTAssertEqual(replaced.properties["end_state"] as? String, "replaced")
+        XCTAssertEqual(replaced.properties["duration_ms"] as? Int64, 10000)
+        // The replaced stream's own late terminal status is not reported again.
+        XCTAssertNil(stream("stopped", terminal: true, nowMs: 12000))
+        XCTAssertNil(tracker.streamStatus(
+            streamId: "s2", state: "streaming", terminal: nil, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: nil, nowMs: 12000
+        ))
+        let second = try XCTUnwrap(tracker.streamStatus(
+            streamId: "s2", state: "stopped", terminal: true, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: nil, nowMs: 20000
+        ))
+        XCTAssertEqual(second.properties["protocol"] as? String, "srt")
+        XCTAssertEqual(second.properties["duration_ms"] as? Int64, 8000)
+    }
+
+    func testOlderGlassesEndAStreamOnStoppedAndErrorDetailsLoseTheirUrls() throws {
+        _ = tracker.streamRequested(streamId: "s2", streamUrl: "https://whip.example.com/whip/abc", nowMs: 0)
+        XCTAssertNil(tracker.streamStatus(
+            streamId: nil, state: "streaming", terminal: nil, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: nil, nowMs: 500
+        ))
+        XCTAssertNil(tracker.streamStatus(
+            streamId: nil, state: "error", terminal: nil, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: nil, nowMs: 1000
+        ))
+        let ended = try XCTUnwrap(tracker.streamStatus(
+            streamId: nil, state: "reconnect_failed", terminal: nil, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: "connect to https://whip.example.com/whip/abc failed",
+            nowMs: 9000
+        ))
+        XCTAssertEqual(ended.properties["protocol"] as? String, "whip")
+        XCTAssertEqual(ended.properties["end_state"] as? String, "reconnect_failed")
+        XCTAssertEqual(ended.properties["error_code"] as? String, "connect to <url> failed")
+        XCTAssertEqual(ended.properties["stopped_by_app"] as? Bool, false)
+    }
+
+    func testStreamThatNeverWentLiveEndsWithoutASecondEvent() {
+        _ = tracker.streamRequested(streamId: "s3", streamUrl: "srt://host:9000", nowMs: 0)
+        let failed = tracker.streamStartSettled(
+            streamUrl: "srt://host:9000", width: nil, height: nil, fps: nil, bitrate: nil,
+            captureAudio: true, glassesNetwork: "none", latencyMs: 30000, errorCode: "stream_start_failed"
+        )
+        XCTAssertEqual(failed.properties["success"] as? Bool, false)
+        XCTAssertEqual(failed.properties["error_code"] as? String, "stream_start_failed")
+        XCTAssertEqual(failed.properties["protocol"] as? String, "srt")
+        XCTAssertNil(tracker.streamStatus(
+            streamId: "s3", state: "stopped", terminal: true, reconnectAttempt: nil, bitrate: nil, fps: nil,
+            droppedFrames: nil, temperatureC: nil, errorDetails: nil, nowMs: 1000
+        ))
+        // Nothing live was replaced either.
+        XCTAssertNil(tracker.streamRequested(streamId: "s4", streamUrl: "srt://host:9000", nowMs: 2000))
+    }
+
+    func testStreamProtocolFollowsTheGlassesSchemeMapping() {
+        XCTAssertEqual(BluetoothSdkUsageTracker.streamProtocol("rtmp://a"), "rtmp")
+        XCTAssertEqual(BluetoothSdkUsageTracker.streamProtocol("RTMPS://a"), "rtmp")
+        XCTAssertEqual(BluetoothSdkUsageTracker.streamProtocol("srt://a"), "srt")
+        XCTAssertEqual(BluetoothSdkUsageTracker.streamProtocol("http://a"), "whip")
+        XCTAssertEqual(BluetoothSdkUsageTracker.streamProtocol("rtmpt://a"), "unknown")
+        XCTAssertEqual(BluetoothSdkUsageTracker.streamProtocol("not a url"), "unknown")
+    }
+
+    func testMicSessionEndsWhenTheSourceTurnsOffOrChanges() throws {
+        XCTAssertNil(tracker.observeMic(currentMic: "", transcribing: false, nowMs: 0))
+        XCTAssertNil(tracker.observeMic(currentMic: "glasses", transcribing: false, nowMs: 1000))
+        XCTAssertNil(tracker.observeMic(currentMic: "glasses", transcribing: true, nowMs: 2000))
+
+        let switched = try XCTUnwrap(tracker.observeMic(currentMic: "phone", transcribing: false, nowMs: 11000))
+        XCTAssertEqual(switched.name, "bluetooth_sdk_mic_session")
+        XCTAssertEqual(switched.properties["mic_source"] as? String, "glasses")
+        XCTAssertEqual(switched.properties["duration_ms"] as? Int64, 10000)
+        XCTAssertEqual(switched.properties["local_transcription"] as? Bool, true)
+
+        let off = try XCTUnwrap(tracker.observeMic(currentMic: "", transcribing: false, nowMs: 14000))
+        XCTAssertEqual(off.properties["mic_source"] as? String, "phone")
+        XCTAssertEqual(off.properties["duration_ms"] as? Int64, 3000)
+        XCTAssertEqual(off.properties["local_transcription"] as? Bool, false)
+        XCTAssertNil(tracker.observeMic(currentMic: "", transcribing: false, nowMs: 15000))
+    }
+
+    func testWifiAndHotspotSetupReportOutcomeAndLatency() {
+        let wifi = tracker.wifiSetupSettled(latencyMs: 4000, errorCode: nil)
+        XCTAssertEqual(wifi.properties["success"] as? Bool, true)
+        XCTAssertEqual(wifi.properties["latency_ms"] as? Int64, 4000)
+        XCTAssertEqual(
+            tracker.wifiSetupSettled(latencyMs: 15000, errorCode: "connect_timeout").properties["error_code"] as? String,
+            "connect_timeout"
+        )
+        XCTAssertEqual(tracker.hotspotStartSettled(latencyMs: 2500, errorCode: nil).name, "bluetooth_sdk_hotspot_started")
+    }
+
+    func testOtaSessionIsReportedOnceWithItsStartingVersions() throws {
+        XCTAssertNil(ota("ota-1", "in_progress", nowMs: 0, fromBuild: "38"))
+        XCTAssertNil(ota("ota-1", "step_complete", nowMs: 60000, fromBuild: "39"))
+        let done = try XCTUnwrap(ota("ota-1", "complete", nowMs: 300_000, fromBuild: "40"))
+        XCTAssertEqual(done.name, "bluetooth_sdk_ota_finished")
+        XCTAssertEqual(done.properties["success"] as? Bool, true)
+        XCTAssertEqual(done.properties["duration_ms"] as? Int64, 300_000)
+        XCTAssertEqual(done.properties["from_build_number"] as? String, "38")
+        XCTAssertEqual(done.properties["total_steps"] as? Int, 2)
+        XCTAssertNil(done.properties["failed_step_type"])
+        XCTAssertNil(ota("ota-1", "complete", nowMs: 301_000, fromBuild: "40"))
+
+        let failed = try XCTUnwrap(ota(
+            "ota-2", "failed", nowMs: 0, fromBuild: "40", stepType: "bes",
+            error: "download failed: https://ota.example.com/x.bin"
+        ))
+        XCTAssertEqual(failed.properties["success"] as? Bool, false)
+        XCTAssertEqual(failed.properties["failed_step_type"] as? String, "bes")
+        XCTAssertEqual(failed.properties["error_message"] as? String, "download failed: <url>")
+        XCTAssertNil(failed.properties["duration_ms"])
+    }
+
+    func testRequestTimeoutsAreCappedPerTracker() throws {
+        var capped = BluetoothSdkUsageTracker(maxRequestTimeouts: 2)
+        let first = try XCTUnwrap(capped.requestTimedOut(operation: "photo request"))
+        XCTAssertEqual(first.name, "bluetooth_sdk_request_failed")
+        XCTAssertEqual(first.properties["operation"] as? String, "photo request")
+        XCTAssertEqual(first.properties["error_code"] as? String, "request_timeout")
+        XCTAssertNotNil(capped.requestTimedOut(operation: "start stream"))
+        XCTAssertNil(capped.requestTimedOut(operation: "start stream"))
+    }
+
+    func testDetailsAreSanitizedAndCapped() {
+        XCTAssertNil(BluetoothSdkUsageTracker.sanitizedDetail("   "))
+        XCTAssertEqual(BluetoothSdkUsageTracker.sanitizedDetail(String(repeating: "x", count: 500))?.count, 200)
+    }
+
+    private func stream(
+        _ state: String,
+        terminal: Bool? = nil,
+        reconnectAttempt: Int? = nil,
+        bitrate: Int64? = nil,
+        droppedFrames: Int64? = nil,
+        nowMs: Int64
+    ) -> AnalyticsEvent? {
+        tracker.streamStatus(
+            streamId: "s1", state: state, terminal: terminal, reconnectAttempt: reconnectAttempt, bitrate: bitrate,
+            fps: nil, droppedFrames: droppedFrames, temperatureC: nil, errorDetails: nil, nowMs: nowMs
+        )
+    }
+
+    private func ota(
+        _ sessionId: String,
+        _ status: String,
+        nowMs: Int64,
+        fromBuild: String,
+        stepType: String = "apk",
+        error: String? = nil
+    ) -> AnalyticsEvent? {
+        tracker.otaStatus(
+            sessionId: sessionId, status: status, stepType: stepType, totalSteps: 2, errorMessage: error,
+            fromBuildNumber: fromBuild, fromBesFirmwareVersion: "", fromMtkFirmwareVersion: "", nowMs: nowMs
+        )
+    }
+}

package/ios/Tests/DashboardContentFormatterTests.swift

@@ -5,14 +5,14 @@ final class DashboardContentFormatterTests: XCTestCase {
     func testEmptyContentReturnsStatusHeaderOnly() {
         XCTAssertEqual(
             DashboardContentFormatter.template(for: ""),
-            "$TIME12$ $DATE$ $GBATT$ $CONNECTION_STATUS$"
+            "$TIME12$ $DATE$ $GBATT$"
         )
     }
 
     func testNonEmptyContentIsAppendedExactlyAfterBlankLine() {
         XCTAssertEqual(
             DashboardContentFormatter.template(for: "  Next meeting\nRoom 2  "),
-            "$TIME12$ $DATE$ $GBATT$ $CONNECTION_STATUS$\n\n  Next meeting\nRoom 2  "
+            "$TIME12$ $DATE$ $GBATT$\n\n  Next meeting\nRoom 2  "
         )
     }
 }

package/ios/Tests/DashboardRenderingTests.swift

@@ -15,6 +15,36 @@ final class DashboardRenderingTests: XCTestCase {
         return (manager, display)
     }
 
+    func testFullFrameDashboardHandoffDoesNotClearActiveScene() async {
+        let (manager, display) = setupDashboard()
+        display.sceneHandoffRequiresClear = false
+        await manager.setDashboardContent("new dashboard")
+        XCTAssertEqual(display.cleanupCount, 0)
+        XCTAssertEqual(display.clearDisplayCount, 0)
+        XCTAssertEqual(display.texts.count, 1)
+        XCTAssertTrue(display.texts[0].hasSuffix("new dashboard"))
+    }
+
+    func testHiddenSceneHandoffCannotClearMainView() async {
+        let (manager, display) = setupDashboard()
+        DeviceStore.shared.apply("glasses", "headUp", false)
+        manager.displayEvent([
+            "view": "dashboard",
+            "scene": ["appId": "replacement", "sceneEpoch": 2, "elements": [[String: Any]]()],
+        ])
+        await Task.yield()
+        XCTAssertEqual(display.cleanupCount, 0)
+        XCTAssertEqual(display.clearDisplayCount, 0)
+        XCTAssertTrue(display.scenes.isEmpty)
+    }
+
+    func testNimoOptsOutOfDestructiveTransientOverlays() {
+        let device: SGCManager = Nimo()
+        XCTAssertFalse(device.sceneHandoffRequiresClear)
+        XCTAssertFalse(device.showBrightnessConfirmation)
+        XCTAssertFalse(device.showConnectionConfirmation)
+    }
+
     func testSetterWaitsForCleanupAndLatestContentWins() async {
         let (manager, display) = setupDashboard()
         var firstReturned = false
@@ -74,6 +104,7 @@ final class DashboardRenderingTests: XCTestCase {
 private final class PausedDisplay: SGCManager {
     var type = "Test display"
     let hasMic = false
+    var sceneHandoffRequiresClear = true
     let cleanupStarted = XCTestExpectation(description: "cleanup suspended")
     var cleanupCount = 0
     var clearDisplayCount = 0

package/ios/Tests/DemandDrivenAudioWorkerTests.swift

@@ -0,0 +1,157 @@
+import Foundation
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class DemandDrivenAudioWorkerTests: XCTestCase {
+    private final class Processor {
+        let onRelease: () -> Void
+        init(onRelease: @escaping () -> Void = {}) {
+            self.onRelease = onRelease
+        }
+
+        deinit { onRelease() }
+    }
+
+    func testNoDemandAndEmptyActiveQueueScheduleNoRecurringWork() {
+        let queue = DispatchQueue(label: "test.speech")
+        var creations = 0
+        var processed = [Data]()
+        let worker = DemandDrivenAudioWorker(queue: queue, makeProcessor: {
+            creations += 1
+            return Processor()
+        }, process: { _, data, _ in processed.append(data) })
+        worker.accept(Data([1]))
+        queue.sync {}
+        XCTAssertEqual(creations, 0)
+        worker.setActive(true)
+        worker.setActive(true)
+        queue.sync {}
+        XCTAssertEqual(creations, 1)
+        XCTAssertTrue(worker.snapshot().initialized)
+        XCTAssertFalse(worker.snapshot().processing)
+        // A serial barrier completes with an empty queue; no sleeping consumer holds it.
+        queue.sync {}
+        XCTAssertTrue(processed.isEmpty)
+        worker.setActive(false)
+        queue.sync {}
+        XCTAssertFalse(worker.snapshot().initialized)
+    }
+
+    func testFirstAudioIsRetainedDuringAsynchronousInitializationAndBounded() {
+        let queue = DispatchQueue(label: "test.speech")
+        let loading = DispatchSemaphore(value: 0)
+        let release = DispatchSemaphore(value: 0)
+        var processed = [Data]()
+        let worker = DemandDrivenAudioWorker(capacity: 3, queue: queue, makeProcessor: {
+            XCTAssertFalse(Thread.isMainThread)
+            loading.signal()
+            release.wait()
+            return Processor()
+        }, process: { _, data, _ in processed.append(data) })
+        worker.setActive(true)
+        XCTAssertEqual(loading.wait(timeout: .now() + 2), .success)
+        worker.accept(Data([1]))
+        worker.accept(Data([2]))
+        XCTAssertEqual(worker.snapshot().queuedBuffers, 2)
+        release.signal()
+        queue.sync {}
+        XCTAssertEqual(processed, [Data([1]), Data([2])])
+        worker.setActive(false)
+        queue.sync {}
+    }
+
+    func testStopDuringLoadingDropsOldAudioAndCannotResurrectProcessor() {
+        let queue = DispatchQueue(label: "test.speech")
+        let loading = DispatchSemaphore(value: 0)
+        let release = DispatchSemaphore(value: 0)
+        var released = 0
+        var processed = 0
+        let worker = DemandDrivenAudioWorker(capacity: 2, queue: queue, makeProcessor: {
+            loading.signal()
+            release.wait()
+            return Processor { released += 1 }
+        }, process: { _, _, _ in processed += 1 })
+        worker.setActive(true)
+        XCTAssertEqual(loading.wait(timeout: .now() + 2), .success)
+        for byte: UInt8 in 1 ... 10 {
+            worker.accept(Data([byte]))
+        }
+        XCTAssertEqual(worker.snapshot().queuedBuffers, 2)
+        XCTAssertEqual(worker.snapshot().droppedBuffers, 8)
+        worker.setActive(false)
+        XCTAssertEqual(worker.snapshot().queuedBuffers, 0)
+        release.signal()
+        queue.sync {}
+        XCTAssertEqual(processed, 0)
+        XCTAssertEqual(released, 1)
+        XCTAssertFalse(worker.snapshot().initialized)
+    }
+
+    func testRestartAndRapidDemandChangesSerializeOldAndNewProcessors() {
+        let queue = DispatchQueue(label: "test.speech")
+        let processing = DispatchSemaphore(value: 0)
+        let release = DispatchSemaphore(value: 0)
+        var creations = 0
+        var destructions = 0
+        var tokens = [UInt64]()
+        var dataSeen = [Data]()
+        let worker = DemandDrivenAudioWorker(queue: queue, makeProcessor: {
+            XCTAssertEqual(creations, destructions)
+            creations += 1
+            return Processor { destructions += 1 }
+        }, process: { _, data, token in
+            dataSeen.append(data)
+            tokens.append(token)
+            if data == Data([1]) {
+                processing.signal()
+                release.wait()
+            }
+        })
+        worker.setActive(true)
+        worker.accept(Data([1]))
+        XCTAssertEqual(processing.wait(timeout: .now() + 2), .success)
+        worker.accept(Data([2]))
+        worker.restart()
+        worker.setActive(false)
+        worker.setActive(true)
+        worker.accept(Data([3]))
+        release.signal()
+        queue.sync {}
+        XCTAssertEqual(dataSeen, [Data([1]), Data([3])])
+        XCTAssertFalse(worker.isCurrent(tokens[0]))
+        XCTAssertTrue(worker.isCurrent(tokens[1]))
+        XCTAssertEqual(creations, 2)
+        worker.setActive(false)
+        queue.sync {}
+        XCTAssertEqual(destructions, 2)
+        XCTAssertFalse(worker.isCurrent(tokens[1]))
+    }
+
+    func testMissingModelDoesNotRetryEveryFrameAndRestartWithoutDemandDoesNotLoad() {
+        let queue = DispatchQueue(label: "test.speech")
+        var attempts = 0
+        let worker = DemandDrivenAudioWorker<Processor>(queue: queue, makeProcessor: {
+            attempts += 1
+            return nil
+        }, process: { _, _, _ in XCTFail("Missing processor") })
+        worker.restart()
+        queue.sync {}
+        XCTAssertEqual(attempts, 0)
+        worker.setActive(true)
+        for _ in 0 ..< 5 {
+            worker.accept(Data([1]))
+            queue.sync {}
+        }
+        XCTAssertEqual(attempts, 1)
+        XCTAssertEqual(worker.snapshot().queuedBuffers, 0)
+        worker.restart()
+        queue.sync {}
+        XCTAssertEqual(attempts, 2)
+        worker.setActive(false)
+        worker.setActive(true)
+        queue.sync {}
+        XCTAssertEqual(attempts, 3)
+        worker.setActive(false)
+        queue.sync {}
+    }
+}

package/ios/Tests/DeviceIdentityPairingTests.swift

@@ -0,0 +1,49 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+@MainActor
+final class DeviceIdentityPairingTests: XCTestCase {
+    func testReadinessPromotesCoherentIdentityAndPreservesSameDeviceReconnects() {
+        let store = DeviceStore.shared.store
+        let saved = ["bluetooth", "glasses"].map { ($0, store.getCategory($0)) }
+        defer {
+            for (category, values) in saved {
+                for key in store.getCategory(category).keys where values[key] == nil {
+                    store.remove(category, key)
+                }
+                for (key, value) in values {
+                    store.set(category, key, value)
+                }
+            }
+        }
+        let cases = [
+            // pending name, pending address, saved model, expected address
+            ("new", "", "test", ""),
+            ("new", "new-address", "test", "new-address"),
+            ("old", "", "test", "old-address"),
+            ("", "", "test", "old-address"),
+            ("old", "", "other-model", ""),
+        ]
+        for (pendingName, pendingAddress, savedModel, expectedAddress) in cases {
+            let manager = DeviceManager()
+            let device = Simulated()
+            device.type = "test"
+            manager.sgc = device
+            defer {
+                manager.disconnect()
+                manager.cleanup()
+            }
+            store.set("bluetooth", "default_wearable", savedModel)
+            store.set("bluetooth", "device_name", "old")
+            store.set("bluetooth", "device_address", "old-address")
+            store.set("bluetooth", "pending_device_name", pendingName)
+            store.set("bluetooth", "pending_device_address", pendingAddress)
+            store.set("bluetooth", "shouldSendBootingMessage", false)
+            manager.handleDeviceReady()
+            XCTAssertEqual(DeviceStore.shared.get("bluetooth", "device_name") as? String, pendingName.isEmpty ? "old" : pendingName)
+            XCTAssertEqual(DeviceStore.shared.get("bluetooth", "device_address") as? String, expectedAddress)
+            XCTAssertEqual(DeviceStore.shared.get("bluetooth", "pending_device_name") as? String, "")
+            XCTAssertEqual(DeviceStore.shared.get("bluetooth", "pending_device_address") as? String, "")
+        }
+    }
+}