@glassly/bluetooth-sdk 0.1.0-dev.99 → 0.2.8-dev.445

package/ios/Source/speakerid/SpeakerIdEngine.swift

@@ -16,7 +16,7 @@
 
 import Foundation
 
-#if !SWIFT_PACKAGE || GLASSLY_FEATURE_LOCAL_STT
+#if !SWIFT_PACKAGE || FEATURE_LOCAL_STT
 
 final class SpeakerIdEngine {
     static let shared = SpeakerIdEngine()
@@ -537,7 +537,7 @@ final class SpeakerIdEngine {
 
 #else
 
-/// Stub for SWIFT_PACKAGE builds without GLASSLY_FEATURE_LOCAL_STT — the
+/// Stub for SWIFT_PACKAGE builds without FEATURE_LOCAL_STT — the
 /// sherpa-onnx runtime isn't linked, so speaker ID is unavailable.
 final class SpeakerIdEngine {
     static let shared = SpeakerIdEngine()

package/ios/Source/status/DeviceStatus.swift

@@ -113,6 +113,9 @@ struct GlassesStatus: CustomStringConvertible {
             "connectionState": "DISCONNECTED",
             "fullyBooted": false,
             "batteryLevel": -1,
+            "ringConnected": false,
+            "ringBatteryLevel": -1,
+            "ringCharging": false,
             "charging": false,
             "hotspotEnabled": false,
             "hotspotGatewayIp": "",
@@ -250,6 +253,18 @@ struct GlassesStatus: CustomStringConvertible {
         boolValue(values, "charging") ?? false
     }
 
+    var ringConnected: Bool {
+        boolValue(values, "ringConnected") ?? false
+    }
+
+    var ringBatteryLevel: Int {
+        intValue(values["ringBatteryLevel"]) ?? -1
+    }
+
+    var ringCharging: Bool {
+        boolValue(values, "ringCharging") ?? false
+    }
+
     var caseBatteryLevel: Int {
         intValue(values["caseBatteryLevel"]) ?? -1
     }
@@ -756,6 +771,18 @@ struct GlassesStatusUpdate: CustomStringConvertible {
         optionalBoolValue(values, "charging")
     }
 
+    var ringConnected: Bool? {
+        optionalBoolValue(values, "ringConnected")
+    }
+
+    var ringBatteryLevel: Int? {
+        optionalIntValue(values, "ringBatteryLevel")
+    }
+
+    var ringCharging: Bool? {
+        optionalBoolValue(values, "ringCharging")
+    }
+
     var caseBatteryLevel: Int? {
         optionalIntValue(values, "caseBatteryLevel")
     }

package/ios/Source/stt/SherpaOnnxTranscriber.swift

@@ -1,5 +1,4 @@
 import Foundation
-import UIKit
 
 /**
  * SherpaOnnxTranscriber handles real-time audio transcription using Sherpa-ONNX.
@@ -24,9 +23,6 @@ class SherpaOnnxTranscriber {
 
     private var lastPartialResult = ""
 
-    /// Parent context
-    private weak var context: UIViewController?
-
     /// Session start time for relative timestamps
     private var transcriptionSessionStart: Date
 
@@ -90,10 +86,9 @@ class SherpaOnnxTranscriber {
     }
 
     /**
-     * Constructor that accepts a UIViewController to load model assets.
+     * Model assets come from the saved path; no UI context is needed.
      */
-    init(context: UIViewController) {
-        self.context = context
+    init() {
         transcriptionSessionStart = Date()
     }
 
@@ -105,7 +100,7 @@ class SherpaOnnxTranscriber {
      * Initialize the Sherpa-ONNX recognizer.
      * Loads models and configuration, sets up processing thread.
      */
-    func initialize() {
+    func initialize() throws {
         do {
             var tokensPath: String
             var modelType = "unknown"
@@ -245,22 +240,24 @@ class SherpaOnnxTranscriber {
             } else {
                 Bridge.log("No Sherpa ONNX model available. Transcription will be disabled.")
                 Bridge.log("Please download a model using the model downloader in settings.")
-                recognizer = nil
-                isRunning = false
-                return
+                throw NSError(domain: "LocalSTT", code: 2, userInfo: [
+                    NSLocalizedDescriptionKey: "No offline speech model has been selected",
+                ])
             }
 
             if recognizer == nil {
                 throw NSError(domain: "SherpaOnnxTranscriber", code: 2, userInfo: [NSLocalizedDescriptionKey: "Failed to create recognizer"])
             }
 
-            startProcessingTask()
             isRunning = true
+            startProcessingTask()
 
             Bridge.log("Sherpa-ONNX ASR initialized successfully with \(modelType) model")
 
         } catch {
             Bridge.log("Failed to initialize Sherpa-ONNX: \(error.localizedDescription)")
+            shutdown()
+            throw error
         }
     }
 
@@ -431,6 +428,10 @@ class SherpaOnnxTranscriber {
 
         isRunning = false
         processingTask?.cancel()
+        // Join the old loop before a restart sets isRunning=true again.
+        processingQueue?.sync {}
+        processingTask = nil
+        processingQueue = nil
 
         // Synchronize access to recognizer during shutdown
         objc_sync_enter(self)
@@ -458,9 +459,9 @@ class SherpaOnnxTranscriber {
      * Restarts the transcriber after a model change.
      * Shuts down existing resources, clears buffers, and reinitializes the recognizer.
      */
-    func restart() {
+    func restart() throws {
         Bridge.log("♻️ Restarting SherpaOnnxTranscriber...")
         shutdown()
-        initialize()
+        try initialize()
     }
 }

package/ios/Source/utils/Enums.swift

@@ -1,6 +1,5 @@
 //
 //  Enums.swift
-//  Glassly_Manager
 //
 //  Created by Matthew Fosse on 3/3/25.
 //

package/ios/Source/utils/G1Text.swift

@@ -1,6 +1,5 @@
 //
 //  G1Text.swift
-//  Glassly_Manager
 //
 //  Created by Matthew Fosse on 3/5/25.
 //

package/ios/Source/utils/G2NotifyFile.swift

@@ -12,6 +12,16 @@ import Foundation
 enum G2NotifyFile {
     static let whitelistFilename = "user/notify_whitelist.json"
 
+    /// eEvenFileServiceType from the stock app's efs_transmit.proto. The
+    /// firmware's `_efsFileCmdParse` dispatches on this word alone: the
+    /// filename is not consulted, and a notification-typed file whose JSON
+    /// has no `android_notification` node leaves a blank card in the stock
+    /// notification viewer.
+    enum FileType: UInt32 {
+        case whitelist = 0 // NOTIFICATION_JSON_WHITELIST
+        case androidNotification = 1 // ANDROID_MSG_JSON_NOTIFICATION
+    }
+
     /// Firmware caps: 100-app list, 80-byte records (64-byte identifier
     /// including NUL, 16-byte display name including NUL).
     static let maxApps = 100
@@ -41,18 +51,18 @@ enum G2NotifyFile {
         return crc
     }
 
-    /// 93-byte FILE_CHECK payload: mode, size, split CRC-32C, 80-byte
-    /// NUL-padded filename. The glasses reconstruct the checksum as
-    /// `(extra << 24) | (checksum >> 8)`.
-    static func fileCheckHeader(filename: String, content: Data) -> Data {
+    /// 93-byte FILE_CHECK payload as the firmware reads it: SEND_START command
+    /// byte, then u32 file type, u32 size, u32 CRC-32C and the 80-byte
+    /// NUL-padded filename. (The even-g2-protocol docs describe the same
+    /// bytes shifted by one — "mode 0x100, size * 256, crc << 8, extra" — which
+    /// hides that "mode 0x100" is file type 1, the Android notification.)
+    static func fileCheckHeader(filename: String, content: Data, fileType: FileType) -> Data {
         let crc = crc32c(content)
         var header = Data()
-        // Mode 0x100: the even-g2-protocol docs' prose says 0x00010000, but the
-        // working example (`notification.py`) packs `<I` 0x100 — trust the code.
-        header.appendLittleEndianUInt32(0x100) // mode
-        header.appendLittleEndianUInt32(UInt32(content.count) &* 256) // size
-        header.appendLittleEndianUInt32(crc << 8) // checksum (low 24 bits, shifted)
-        header.append(UInt8(crc >> 24)) // extra (high CRC byte)
+        header.append(0x00) // eEvenFileSendServiceCID SEND_START
+        header.appendLittleEndianUInt32(fileType.rawValue)
+        header.appendLittleEndianUInt32(UInt32(content.count))
+        header.appendLittleEndianUInt32(crc)
         var name = Array(filename.utf8)
         if name.count > 80 {
             name = Array(name.prefix(80))

package/ios/Source/utils/JSCExperiment.swift

@@ -3,7 +3,7 @@
 //  Glassly
 //
 //  Test/benchmark infrastructure. Self-contained file, never invoked in
-//  normal user flow. Triggered only when (a) GLASSLY_RUN_JSC_BENCH env
+//  normal user flow. Triggered only when (a) RUN_JSC_BENCH env
 //  var is set at app launch, or (b) the user taps a JSC button on the
 //  (Super-Mode-gated) stress-test screen.
 //
@@ -17,7 +17,7 @@
 //   - Has __dispatch as a single bridge function (no per-method bindings,
 //     to avoid the production crash Pebble documented in CrashReproducer.kt)
 //   - Runs a representative idle workload: setInterval ping every 5 s
-//   - Names itself "GlasslyJS: <id>" for Safari Web Inspector
+//   - Names itself "JSRuntime: <id>" for Safari Web Inspector
 //   - Is NOT inspectable in release builds
 //
 //  Measure resident memory before and after spawning N contexts.
@@ -57,12 +57,12 @@ private func jlog(_ message: String) {
 }
 
 @objc class JSCExperiment: NSObject {
-    /// Called from BluetoothSdkModule init. If GLASSLY_RUN_JSC_BENCH env var
+    /// Called from BluetoothSdkModule init. If RUN_JSC_BENCH env var
     /// is set, kick off the benchmark after a 5s settle window so the app
     /// is fully booted (RN bridge up, Metro pull done if dev, etc).
     @objc static func maybeAutoBenchmark() {
-        guard ProcessInfo.processInfo.environment["GLASSLY_RUN_JSC_BENCH"] != nil else { return }
-        os_log("🧪 GLASSLY_RUN_JSC_BENCH set — auto-running benchmark in 5s",
+        guard ProcessInfo.processInfo.environment["RUN_JSC_BENCH"] != nil else { return }
+        os_log("🧪 RUN_JSC_BENCH set — auto-running benchmark in 5s",
                log: jscLog, type: .info)
         DispatchQueue.global(qos: .userInitiated).asyncAfter(deadline: .now() + 5.0) {
             runBenchmark()
@@ -99,7 +99,7 @@ private func jlog(_ message: String) {
             let vm = JSVirtualMachine()!
             let ctx = JSContext(virtualMachine: vm)!
 
-            ctx.name = "GlasslyJS: \(id)"
+            ctx.name = "JSRuntime: \(id)"
             // Inspectable in dev builds only. iOS 16.4+ guarded.
             #if DEBUG
                 if #available(iOS 16.4, *) {

package/ios/Source/utils/Models.swift

@@ -1,6 +1,5 @@
 //
 //  Models.swift
-//  Glassly_Manager
 //
 //  Created by Matthew Fosse on 3/3/25.
 //

package/ios/Tests/BluetoothSDKTests/BluetoothAvailabilityTests.swift

@@ -0,0 +1,29 @@
+@testable import BluetoothSDK
+import XCTest
+
+/// Building the SDK must not create a `CBCentralManager`: that is what shows
+/// the iOS Bluetooth permission alert, and the Expo module builds the SDK at
+/// app launch. A regression here prompts a fresh install before onboarding.
+///
+/// One method on purpose: `BluetoothAvailability` is a process-wide
+/// singleton, so the "not yet activated" assertion has to run before the
+/// first command activates it.
+@MainActor
+final class BluetoothAvailabilityTests: XCTestCase {
+    func testCentralManagerIsCreatedByTheFirstCommandNotBySdkInit() throws {
+        XCTAssertFalse(BluetoothAvailability.shared.isActivated)
+
+        let sdk = BluetoothSDK()
+        defer { sdk.invalidate() }
+        XCTAssertFalse(
+            BluetoothAvailability.shared.isActivated,
+            "SDK init created a CBCentralManager, which prompts for Bluetooth at launch"
+        )
+
+        // The first command activates the manager. CoreBluetooth has not
+        // reported a state yet, so the gate lets the command through instead
+        // of failing with bluetooth_not_ready.
+        XCTAssertNoThrow(try BluetoothAvailability.shared.requirePoweredOn(operation: "test"))
+        XCTAssertTrue(BluetoothAvailability.shared.isActivated)
+    }
+}

package/ios/Tests/BluetoothSDKTests/DisplayPacerTests.swift

@@ -0,0 +1,255 @@
+@testable import BluetoothSDK
+import Foundation
+import XCTest
+
+@MainActor
+final class DisplayPacerTests: XCTestCase {
+    @MainActor private final class Harness {
+        var now: Int64 = 1000
+        var delay: Int64?
+        var block: (@MainActor () -> Void)?
+        var scheduled = 0
+        var scenes: [SceneFrame] = []
+        var legacySends = 0
+        var pacer: DisplayPacer!
+
+        init(fps: Int = 8) {
+            pacer = DisplayPacer(
+                dispatchScene: { [unowned self] in self.scenes.append($0) },
+                sendLegacy: { [unowned self] in self.legacySends += 1 },
+                clock: { [unowned self] in self.now },
+                scheduler: { [unowned self] delayMs, block in
+                    self.scheduled += 1
+                    self.delay = delayMs
+                    self.block = block
+                    let token = self.scheduled
+                    return {
+                        if self.scheduled == token {
+                            self.block = nil
+                            self.delay = nil
+                        }
+                    }
+                }
+            )
+            pacer.setMaxFps(fps)
+        }
+
+        func fire() {
+            guard let b = block else { XCTFail("no timer armed"); return }
+            block = nil
+            delay = nil
+            b()
+        }
+    }
+
+    private func element(_ id: String, change: String = "created", x: Int32 = 0) -> SceneElement {
+        SceneElement(
+            id: id, type: "text", x: x, y: 0, w: 10, h: 10, text: id, data: nil, border: 0, radius: 0,
+            change: change, contentHash: "h-\(id)"
+        )
+    }
+
+    private func frame(
+        _ elements: [SceneElement], removed: [String] = [], appId: String = "app", replay: Bool = false,
+        epoch: Int = 1
+    ) -> SceneFrame {
+        SceneFrame(appId: appId, epoch: epoch, replay: replay, elements: elements, removed: removed)
+    }
+
+    private func change(_ frame: SceneFrame, _ id: String) -> String? {
+        frame.elements.first { $0.id == id }?.change
+    }
+
+    func testFirstSubmitSendsImmediately() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertNil(h.block)
+    }
+
+    func testSecondSubmitInsideWindowIsHeldUntilTheSlot() {
+        let h = Harness(fps: 10)
+        h.pacer.submitScene(frame([element("a")], epoch: 1))
+        h.now += 30
+        h.pacer.submitScene(frame([element("a", change: "updated")], epoch: 2))
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertEqual(h.delay, 70)
+        h.now += 70
+        h.fire()
+        XCTAssertEqual(h.scenes.count, 2)
+        XCTAssertEqual(h.scenes[1].epoch, 2)
+    }
+
+    func testRapidFramesCoalesceIntoOneMergedSend() {
+        let h = Harness(fps: 10)
+        h.pacer.submitScene(frame([element("a")], epoch: 1))
+        h.now += 10
+        h.pacer.submitScene(frame([element("a", change: "updated"), element("b", change: "created")], epoch: 2))
+        h.now += 10
+        h.pacer.submitScene(frame([element("a", change: "unchanged"), element("b", change: "moved", x: 5)], epoch: 3))
+        h.now += 10
+        h.pacer.submitScene(
+            frame([element("a", change: "unchanged"), element("b", change: "unchanged", x: 5)], epoch: 4)
+        )
+        XCTAssertEqual(h.scheduled, 1)
+        h.now += 70
+        h.fire()
+        XCTAssertEqual(h.scenes.count, 2)
+        let sent = h.scenes[1]
+        XCTAssertEqual(sent.epoch, 4)
+        XCTAssertEqual(change(sent, "a"), "updated")
+        XCTAssertEqual(change(sent, "b"), "created")
+        XCTAssertEqual(sent.elements.first { $0.id == "b" }?.x, 5)
+    }
+
+    func testUpdatedThenUnchangedBecomesUpdated() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "moved", x: 3)]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged", x: 3)]))
+        h.now += 200
+        h.fire()
+        XCTAssertEqual(change(h.scenes[1], "a"), "updated")
+    }
+
+    func testRemovedThenRecreatedIdIsNotRemoved() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a"), element("b")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged")], removed: ["b"]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged"), element("b", change: "created")]))
+        h.now += 200
+        h.fire()
+        XCTAssertTrue(h.scenes[1].removed.isEmpty)
+        XCTAssertEqual(change(h.scenes[1], "b"), "created")
+    }
+
+    func testPendingRemovesSurviveIntoTheMergedFrame() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a"), element("b"), element("c")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged")], removed: ["b", "c"]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged")], removed: ["c"]))
+        h.now += 200
+        h.fire()
+        XCTAssertEqual(h.scenes[1].removed, ["b", "c"])
+    }
+
+    func testAppSwitchDiscardsPending() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")], appId: "one"))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "updated")], removed: ["z"], appId: "one"))
+        h.now += 1
+        h.pacer.submitScene(frame([element("b", change: "created")], appId: "two", replay: true))
+        h.now += 200
+        h.fire()
+        let sent = h.scenes[1]
+        XCTAssertEqual(sent.appId, "two")
+        XCTAssertTrue(sent.removed.isEmpty)
+        XCTAssertEqual(sent.elements.map(\.id), ["b"])
+    }
+
+    func testEmptyFrameFlushesImmediatelyWithPendingRemoves() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a"), element("b")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "unchanged")], removed: ["b"]))
+        h.now += 1
+        h.pacer.flushScene(frame([], removed: ["a"]))
+        XCTAssertEqual(h.scenes.count, 2)
+        XCTAssertEqual(Set(h.scenes[1].removed), ["a", "b"])
+        XCTAssertTrue(h.scenes[1].elements.isEmpty)
+        XCTAssertNil(h.block)
+        h.now += 200
+        h.pacer.setMaxFps(8)
+        XCTAssertEqual(h.scenes.count, 2)
+    }
+
+    func testClearViewFlushesImmediatelyAndDropsPendingScene() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        XCTAssertNotNil(h.block)
+        h.pacer.flushLegacy()
+        XCTAssertEqual(h.legacySends, 1)
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertNil(h.block)
+    }
+
+    func testLegacyAfterSceneDropsThePendingScene() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        h.now += 1
+        h.pacer.submitLegacy()
+        h.now += 200
+        h.fire()
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertEqual(h.legacySends, 1)
+    }
+
+    func testSceneAfterLegacyDropsThePendingLegacy() {
+        let h = Harness()
+        h.pacer.submitLegacy()
+        XCTAssertEqual(h.legacySends, 1)
+        h.now += 1
+        h.pacer.submitLegacy()
+        h.now += 1
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 200
+        h.fire()
+        XCTAssertEqual(h.legacySends, 1)
+        XCTAssertEqual(h.scenes.count, 1)
+    }
+
+    func testSetMaxFpsRearmsAPendingTimer() {
+        let h = Harness(fps: 2)
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 50
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        XCTAssertEqual(h.delay, 450)
+        h.pacer.setMaxFps(20)
+        XCTAssertEqual(h.scenes.count, 2)
+        XCTAssertNil(h.block)
+
+        h.now += 10
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        XCTAssertEqual(h.delay, 40)
+        h.pacer.setMaxFps(10)
+        XCTAssertEqual(h.delay, 90)
+        XCTAssertEqual(h.scenes.count, 2)
+    }
+
+    func testCancelDropsPendingWithoutSending() {
+        let h = Harness()
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 1
+        h.pacer.submitScene(frame([element("a", change: "updated")]))
+        h.pacer.cancel()
+        XCTAssertNil(h.block)
+        h.now += 200
+        h.pacer.setMaxFps(8)
+        XCTAssertEqual(h.scenes.count, 1)
+        XCTAssertNil(h.block)
+    }
+
+    func testLateSubmitAfterTheSlotSendsMergedImmediately() {
+        let h = Harness(fps: 10)
+        h.pacer.submitScene(frame([element("a")]))
+        h.now += 10
+        h.pacer.submitScene(frame([element("a", change: "updated"), element("b", change: "created")]))
+        h.now += 200
+        h.pacer.submitScene(frame([element("a", change: "unchanged"), element("b", change: "unchanged")]))
+        XCTAssertEqual(h.scenes.count, 2)
+        XCTAssertEqual(change(h.scenes[1], "a"), "updated")
+        XCTAssertEqual(change(h.scenes[1], "b"), "created")
+        XCTAssertNil(h.block)
+    }
+}