@glassly/bluetooth-sdk 0.1.0-dev.26

package/ios/Source/DeviceStore.swift

@@ -0,0 +1,336 @@
+//
+//  DeviceStore.swift
+//  BluetoothSDK
+//
+//  Centralized observable state store for glasses and Bluetooth SDK settings
+//
+
+import Foundation
+
+@MainActor
+class DeviceStore {
+    static let shared = DeviceStore()
+    let store = ObservableStore()
+
+    private var dashboardHeightDebounceTask: Task<Void, Never>?
+    private var dashboardDepthDebounceTask: Task<Void, Never>?
+
+    private init() {
+        // SETTINGS are snake_case
+        // CORE STATE is camelCase
+
+        // GLASSES STATE:
+        store.set("glasses", "fullyBooted", false)
+        store.set("glasses", "batteryLevel", -1)
+        store.set("glasses", "charging", false)
+        store.set("glasses", "connected", false)
+        store.set("glasses", "connectionState", ConnTypes.DISCONNECTED)
+        store.set("glasses", "deviceModel", "")
+        store.set("glasses", "firmwareVersion", "")
+        store.set("glasses", "hotspotOtaVersion", 0)
+        store.set("glasses", "micEnabled", false)
+        store.set("glasses", "voiceActivityDetectionEnabled", BluetoothSdkDefaults.voiceActivityDetectionEnabled)
+        store.set("glasses", "bluetoothClassicConnected", false)
+        store.set("glasses", "caseRemoved", true)
+        store.set("glasses", "caseOpen", true)
+        store.set("glasses", "caseCharging", false)
+        store.set("glasses", "caseBatteryLevel", -1)
+        store.set("glasses", "headUp", false)
+        store.set("glasses", "bluetoothMacAddress", "")
+        store.set("glasses", "wifiMacAddress", "")
+        store.set("glasses", "leftMacAddress", "")
+        store.set("glasses", "rightMacAddress", "")
+        store.set("glasses", "serialNumber", "")
+        store.set("glasses", "style", "")
+        store.set("glasses", "color", "")
+        store.set("glasses", "wifiSsid", "")
+        store.set("glasses", "wifiConnected", false)
+        store.set("glasses", "wifiLocalIp", "")
+        store.set("glasses", "hotspotEnabled", false)
+        store.set("glasses", "hotspotSsid", "")
+        store.set("glasses", "hotspotPassword", "")
+        store.set("glasses", "hotspotGatewayIp", "")
+        store.set("glasses", "bluetoothName", "")
+        store.set("glasses", "macAddress", "")
+        store.set("glasses", "controllerConnected", false)
+        store.set("glasses", "controllerMacAddress", "")
+        store.set("glasses", "controllerBatteryLevel", -1)
+        store.set("glasses", "controllerSignalStrength", -1)
+        store.set("glasses", "signalStrength", -1)
+        store.set("glasses", "signalStrengthUpdatedAt", 0)
+        store.set("glasses", "ringSignalStrength", -1)
+
+        // CORE STATE:
+        store.set("bluetooth", "systemMicUnavailable", false)
+        store.set("bluetooth", "searching", false)
+        store.set("bluetooth", "searchingController", false)
+        store.set("bluetooth", "micEnabled", false)
+        store.set("bluetooth", "currentMic", "")
+        store.set("bluetooth", "searchResults", [])
+        store.set("bluetooth", "wifiScanResults", [])
+        store.set("bluetooth", "micRanking", MicMap.map["auto"]!)
+        store.set("bluetooth", "lastLog", [])
+        store.set("bluetooth", "otherBtConnected", false)
+
+        // CORE SETTINGS:
+        store.set("bluetooth", "default_wearable", "")
+        store.set("bluetooth", "pending_wearable", "")
+        store.set("bluetooth", "device_name", "")
+        store.set("bluetooth", "device_address", "")
+        store.set("bluetooth", "default_controller", "")
+        store.set("bluetooth", "pending_controller", "")
+        store.set("bluetooth", "controller_device_name", "")
+        store.set("bluetooth", "screen_disabled", false)
+        store.set("bluetooth", "preferred_mic", "auto")
+        store.set("bluetooth", "sensing_enabled", true)
+        store.set("bluetooth", "power_saving_mode", false)
+        store.set("bluetooth", "brightness", 50)
+        store.set("bluetooth", "auto_brightness", true)
+        store.set("bluetooth", "dashboard_height", 4)
+        store.set("bluetooth", "dashboard_depth", 2)
+        store.set("bluetooth", "head_up_angle", 30)
+        store.set("bluetooth", "imu_enabled", false)
+        store.set("bluetooth", "contextual_dashboard", true)
+        store.set("bluetooth", "gallery_mode", true)
+        store.set("bluetooth", "voice_activity_detection_enabled", BluetoothSdkDefaults.voiceActivityDetectionEnabled)
+        store.set("bluetooth", "loudness_gate_enabled", BluetoothSdkDefaults.loudnessGateEnabled)
+        // Mentra Nex feature flag (off by default; toggled from Nex Developer Settings):
+        store.set("bluetooth", "nex_chinese_captions", false)
+        store.set("bluetooth", "screen_disabled", false)
+        store.set("bluetooth", "button_photo_size", "max")
+        store.set("bluetooth", "button_max_recording_time", 10)
+        store.set("bluetooth", "camera_fov", ["fov": 118, "roi_position": 0])
+        store.set("bluetooth", "button_video_width", 1280)
+        store.set("bluetooth", "button_video_height", 720)
+        store.set("bluetooth", "button_video_fps", 30)
+        store.set("bluetooth", "preferred_mic", "auto")
+        store.set("bluetooth", "lc3_frame_size", 60)
+        store.set("bluetooth", "auth_email", "")
+        store.set("bluetooth", "core_token", "")
+        store.set("bluetooth", "should_send_pcm", false)
+        store.set("bluetooth", "should_send_lc3", false)
+        store.set("bluetooth", "should_send_transcript", false)
+        store.set("bluetooth", "use_native_dashboard", false)
+        // Debug escape hatch: G2 CFW direct-framebuffer rendering (off = stock containers).
+        store.set("bluetooth", "cfw_scene_renderer", true)
+    }
+
+    func get(_ category: String, _ key: String) -> Any? {
+        return store.get(category, key)
+    }
+
+    func set(_ category: String, _ key: String, _ value: Any) {
+        store.set(category, key, value)
+    }
+
+    func remove(_ category: String, _ key: String) {
+        store.remove(category, key)
+    }
+
+    private func scheduleDashboardHeightToGlasses() {
+        dashboardHeightDebounceTask?.cancel()
+        dashboardHeightDebounceTask = Task { @MainActor in
+            try? await Task.yield()
+            let h = store.get("bluetooth", "dashboard_height") as? Int ?? 4
+            DeviceManager.shared.sgc?.setDashboardHeightOnly(h)
+        }
+    }
+
+    private func scheduleDashboardDepthToGlasses() {
+        dashboardDepthDebounceTask?.cancel()
+        dashboardDepthDebounceTask = Task { @MainActor in
+            try? await Task.yield()
+            let d = store.get("bluetooth", "dashboard_depth") as? Int ?? 2
+            DeviceManager.shared.sgc?.setDashboardDepthOnly(d)
+        }
+    }
+
+    /// Apply changes with side effects
+    func apply(_ category: String, _ key: String, _ value: Any) {
+        let oldValue = store.get(category, key)
+        let storeWouldSkipSet = store.wouldSkipSet(category, key, value)
+        store.set(category, key, value)
+        if storeWouldSkipSet {
+            return
+        }
+
+        // Trigger hardware updates based on setting changes
+        switch (category, key) {
+        case ("glasses", "fullyBooted"):
+            Bridge.log("STORE: Glasses fullyBooted changed to \(value)")
+            if let ready = value as? Bool {
+                if ready {
+                    DeviceManager.shared.handleDeviceReady()
+                } else {
+                    DeviceManager.shared.handleDeviceDisconnected()
+                }
+                // we shouldn't call store.set in this function as this is only intended for side-effects, not driving state updates
+            }
+
+        case ("glasses", "controllerFullyBooted"):
+            if let ready = value as? Bool {
+                if ready {
+                    DeviceManager.shared.handleControllerReady()
+                } else {
+                    DeviceManager.shared.handleControllerDisconnected()
+                }
+            }
+
+        case ("glasses", "controllerMacAddress"):
+            if let mac = value as? String {
+                Task {
+                    // give the glasses some extra time to finish booting:
+                    try? await Task.sleep(nanoseconds: 1_000_000_000)
+                    await DeviceManager.shared.sgc?.connectController()
+                }
+            }
+
+        case ("glasses", "headUp"):
+            if let headUp = value as? Bool {
+                DeviceManager.shared.sendCurrentState()
+                Bridge.sendHeadUp(headUp)
+            }
+
+        // BLUETOOTH:
+
+        case ("bluetooth", "brightness"):
+            let b = value as? Int ?? 50
+            let auto = store.get("bluetooth", "auto_brightness") as? Bool ?? true
+            Task {
+                DeviceManager.shared.sgc?.setBrightness(b, autoMode: auto)
+                await DeviceManager.shared.sgc?.sendTextWall("Set brightness to \(b)%")
+                try? await Task.sleep(nanoseconds: 800_000_000) // 0.8 seconds
+                DeviceManager.shared.sgc?.clearDisplay()
+            }
+
+        case ("bluetooth", "auto_brightness"):
+            let b = store.get("bluetooth", "brightness") as? Int ?? 50
+            let auto = value as? Bool ?? true
+            let autoBrightnessChanged = (oldValue as? Bool) != auto
+            Task {
+                DeviceManager.shared.sgc?.setBrightness(b, autoMode: auto)
+                if autoBrightnessChanged {
+                    await DeviceManager.shared.sgc?.sendTextWall(
+                        auto ? "Enabled auto brightness" : "Disabled auto brightness"
+                    )
+                    try? await Task.sleep(nanoseconds: 800_000_000) // 0.8 seconds
+                    DeviceManager.shared.sgc?.clearDisplay()
+                }
+            }
+
+        case ("bluetooth", "cfw_scene_renderer"):
+            if let enabled = value as? Bool, (oldValue as? Bool) != enabled {
+                Task { await DeviceManager.shared.sgc?.cfwSceneRendererToggled(enabled) }
+            }
+
+        case ("bluetooth", "dashboard_height"):
+            scheduleDashboardHeightToGlasses()
+
+        case ("bluetooth", "dashboard_depth"):
+            scheduleDashboardDepthToGlasses()
+
+        case ("bluetooth", "head_up_angle"):
+            if let angle = value as? Int {
+                DeviceManager.shared.sgc?.setHeadUpAngle(angle)
+            }
+
+        case ("bluetooth", "imu_enabled"):
+            if let enabled = value as? Bool {
+                Task { await DeviceManager.shared.sgc?.setImuEnabled(enabled) }
+            }
+
+        case ("bluetooth", "menu_apps"):
+            if let items = value as? [[String: Any]] {
+                DeviceManager.shared.sgc?.setDashboardMenu(items)
+            }
+
+        case ("bluetooth", "calendar_events"), ("core", "calendar_events"):
+            if let items = value as? [[String: Any]] {
+                DeviceManager.shared.sgc?.sendCalendarEvents(items)
+            }
+
+        case ("bluetooth", "metric_system"), ("bluetooth", "twelve_hour_time"):
+            DeviceManager.shared.sgc?.sendDashboardDisplaySettings()
+
+        case ("bluetooth", "gallery_mode"):
+            DeviceManager.shared.sgc?.sendGalleryMode()
+
+        case ("bluetooth", "voice_activity_detection_enabled"):
+            DeviceManager.shared.sgc?.sendVoiceActivityDetectionSetting()
+
+        case ("bluetooth", "loudness_gate_enabled"):
+            DeviceManager.shared.sgc?.sendLoudnessGateSetting()
+
+        case ("bluetooth", "screen_disabled"):
+            if let disabled = value as? Bool {
+                if disabled {
+                    DeviceManager.shared.sgc?.exit()
+                } else {
+                    DeviceManager.shared.sgc?.clearDisplay()
+                }
+            }
+
+        case ("bluetooth", "button_photo_size"):
+            DeviceManager.shared.sgc?.sendButtonPhotoSettings()
+
+        case ("bluetooth", "button_max_recording_time"):
+            DeviceManager.shared.sgc?.sendButtonMaxRecordingTime()
+
+        case ("bluetooth", "camera_fov"):
+            DeviceManager.shared.sgc?.sendCameraFovSetting()
+
+        case ("bluetooth", "button_video_settings"):
+            DeviceManager.shared.sgc?.sendButtonVideoRecordingSettings()
+
+        // Legacy scalar keys remain supported for older hosts. New code should write the
+        // canonical button_video_settings object so width/height/fps update atomically.
+        case ("bluetooth", "button_video_width"), ("bluetooth", "button_video_height"),
+             ("bluetooth", "button_video_fps"):
+            DeviceManager.shared.sgc?.sendButtonVideoRecordingSettings()
+
+        case ("bluetooth", "preferred_mic"):
+            if let mic = value as? String {
+                apply("bluetooth", "micRanking", MicMap.map[mic] ?? MicMap.map["auto"]!)
+                DeviceManager.shared.setMicState()
+            }
+
+        case ("bluetooth", "local_stt_fallback_active"):
+            if let active = value as? Bool {
+                DeviceManager.shared.setMicState()
+            }
+
+        case ("bluetooth", "should_send_pcm"):
+            if let pcm = value as? Bool {
+                DeviceManager.shared.setMicState()
+            }
+
+        case ("bluetooth", "should_send_lc3"):
+            if let lc3 = value as? Bool {
+                DeviceManager.shared.setMicState()
+            }
+
+        case ("bluetooth", "should_send_transcript"):
+            if let transcript = value as? Bool {
+                DeviceManager.shared.setMicState()
+            }
+
+        case ("bluetooth", "default_wearable"):
+            if let wearable = value as? String {
+                Bridge.saveSetting("default_wearable", wearable)
+                if wearable == DeviceTypes.SIMULATED {
+                    DeviceManager.shared.initSGC(wearable)
+                }
+            }
+
+        case ("bluetooth", "device_name"):
+            if let name = value as? String {
+                DeviceManager.shared.checkCurrentAudioDevice()
+                // listen for when the audio device is paired and connected
+                // DeviceManager.shared.setupAudioPairing(deviceName: name)
+            }
+
+        default:
+            break
+        }
+    }
+}

package/ios/Source/GeneratedChangelogCatalog.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+/// Generated from /changelogs. Do not edit directly.
+let generatedReleaseChangelogs: [ReleaseChangelog] = [
+    ReleaseChangelog(version: "3.1.0", markdown: "Software updates are more reliable, with clearer progress and recovery when the glasses restart.\n\n- GlasslyOS, Glassly Engine, the Bluetooth SDK, and the glasses client now share one coordinated release version.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic."),
+    ReleaseChangelog(version: "0.1.0", markdown: "First coordinated Glassly release: the app, Glassly Engine, and the Bluetooth SDK now ship one shared release version.\n\n- The Glassly App, Glassly Engine, and the Bluetooth SDK are versioned and published together.\n- Mentra Live updates can continue across APK, system, and firmware restarts without asking the user to start the same update again.\n- Bluetooth photo capture and transfer diagnostics are more precise and less disruptive to normal glasses traffic."),
+]

package/ios/Source/GeneratedReleaseMetadata.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+/// Generated by release CI. Do not edit in a release checkout.
+enum GeneratedReleaseMetadata {
+    static let familyBaseVersion = "0.1.0"
+    static let releaseIdentity = "0.1.0-dev.26"
+    static let releaseSetId = "glassly-0.1.0-dev.26"
+    static let sourceCommit = "b63f66924c61de31540b5093d05ff036c756ed74"
+    static let otaManifestUrl = null
+    static let otaManifestSha256 = null
+}

package/ios/Source/ObservableStore.swift

@@ -0,0 +1,118 @@
+//
+//  ObservableStore.swift
+//  BluetoothSdk
+//
+//  Observable state management with immediate event emission
+//
+
+import Foundation
+
+@MainActor
+class ObservableStore {
+    private var values: [String: Any] = [:]
+    private var onEmit: ((String, [String: Any]) -> Void)?
+    private var listeners: [String: (String, [String: Any]) -> Void] = [:]
+
+    nonisolated static let bluetoothCategory = "bluetooth"
+    private nonisolated static let legacyCoreCategory = "core"
+
+    nonisolated static func normalizeCategory(_ category: String) -> String {
+        category == legacyCoreCategory ? bluetoothCategory : category
+    }
+
+    func configure(onEmit: @escaping (String, [String: Any]) -> Void) {
+        self.onEmit = onEmit
+    }
+
+    func addListener(_ listener: @escaping (String, [String: Any]) -> Void) -> String {
+        let id = UUID().uuidString
+        listeners[id] = listener
+        return id
+    }
+
+    func removeListener(_ id: String) {
+        listeners.removeValue(forKey: id)
+    }
+
+    /// Numbers written from the JS bridge arrive as Double even when integral,
+    /// while the seeds (and native readers) use Int. Store integral doubles as
+    /// Int so readers see a stable type and change-detection compares like with
+    /// like. Fractional values and booleans pass through untouched.
+    private nonisolated static func normalizeNumber(_ value: Any) -> Any {
+        guard !(value is Bool), let d = value as? Double,
+              d.truncatingRemainder(dividingBy: 1) == 0,
+              d >= -9_007_199_254_740_992, d <= 9_007_199_254_740_992
+        else { return value }
+        return Int(d)
+    }
+
+    func set(_ category: String, _ key: String, _ value: Any) {
+        let value = Self.normalizeNumber(value)
+        let normalizedCategory = Self.normalizeCategory(category)
+        let fullKey = "\(normalizedCategory).\(key)"
+        let oldValue = values[fullKey]
+
+        // Skip if unchanged
+        if let old = oldValue, areEqual(old, value) {
+            return
+        }
+
+        values[fullKey] = value
+
+        // Emit immediately
+        let changes = [key: value]
+        onEmit?(normalizedCategory, changes)
+        for listener in Array(listeners.values) {
+            listener(normalizedCategory, changes)
+        }
+    }
+
+    func remove(_ category: String, _ key: String) {
+        let normalizedCategory = Self.normalizeCategory(category)
+        let fullKey = "\(normalizedCategory).\(key)"
+        guard values[fullKey] != nil else { return }
+        values.removeValue(forKey: fullKey)
+        // Emit updated category snapshot so UI listeners clear the removed key
+        let snapshot = getCategory(normalizedCategory)
+        onEmit?(normalizedCategory, snapshot)
+        for listener in Array(listeners.values) { listener(normalizedCategory, snapshot) }
+    }
+
+    func get(_ category: String, _ key: String) -> Any? {
+        values["\(Self.normalizeCategory(category)).\(key)"]
+    }
+
+    func wouldSkipSet(_ category: String, _ key: String, _ value: Any) -> Bool {
+        let fullKey = "\(Self.normalizeCategory(category)).\(key)"
+        guard let oldValue = values[fullKey] else { return false }
+        return areEqual(oldValue, Self.normalizeNumber(value))
+    }
+
+    func getCategory(_ category: String) -> [String: Any] {
+        var result: [String: Any] = [:]
+        let prefix = "\(Self.normalizeCategory(category))."
+        for (key, value) in values where key.hasPrefix(prefix) {
+            let shortKey = String(key.dropFirst(prefix.count))
+            result[shortKey] = value
+        }
+        return result
+    }
+
+    /// Helper to compare values
+    private func areEqual(_ lhs: Any, _ rhs: Any) -> Bool {
+        if let l = lhs as? String, let r = rhs as? String { return l == r }
+        if let l = lhs as? Int, let r = rhs as? Int { return l == r }
+        if let l = lhs as? Bool, let r = rhs as? Bool { return l == r }
+        if let l = lhs as? Double, let r = rhs as? Double { return l == r }
+        if let l = lhs as? [String], let r = rhs as? [String] { return l == r }
+        if let l = lhs as? [[String: Any]], let r = rhs as? [[String: Any]] {
+            return toJson(l) == toJson(r)
+        }
+        return false
+    }
+
+    private func toJson(_ value: Any) -> String? {
+        guard let data = try? JSONSerialization.data(withJSONObject: value) else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+}