@glassly/bluetooth-sdk 0.1.0-dev.26

package/ios/Source/errors/BluetoothSdkError.swift

@@ -0,0 +1,19 @@
+import Foundation
+
+public struct BluetoothSdkError: Error, LocalizedError, CustomStringConvertible {
+    public let code: String
+    public let message: String
+
+    public init(code: String, message: String) {
+        self.code = code
+        self.message = message
+    }
+
+    public var errorDescription: String? {
+        message
+    }
+
+    public var description: String {
+        "\(code): \(message)"
+    }
+}

package/ios/Source/events/BluetoothEvents.swift

@@ -0,0 +1,342 @@
+import Foundation
+
+public struct ButtonPressEvent: CustomStringConvertible {
+    public let buttonId: String
+    public let pressType: String
+    public let timestamp: Int?
+
+    public init(buttonId: String, pressType: String, timestamp: Int? = nil) {
+        self.buttonId = buttonId
+        self.pressType = pressType
+        self.timestamp = timestamp
+    }
+
+    public var description: String {
+        "ButtonPressEvent(buttonId: \(buttonId), pressType: \(pressType))"
+    }
+}
+
+public struct TouchEvent: CustomStringConvertible {
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        self.values = values
+    }
+
+    public var deviceModel: String? {
+        stringValue(values, "deviceModel")
+    }
+
+    public var gestureName: String? {
+        stringValue(values, "gestureName")
+    }
+
+    public var timestamp: Int? {
+        intValue(values["timestamp"])
+    }
+
+    public var isSwipe: Bool {
+        gestureName?.localizedCaseInsensitiveContains("swipe") == true
+    }
+
+    public var description: String {
+        "TouchEvent(gestureName: \(gestureName ?? "unknown"))"
+    }
+}
+
+public struct VoiceActivityDetectionStatusEvent: CustomStringConvertible {
+    public let voiceActivityDetectionEnabled: Bool
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        voiceActivityDetectionEnabled =
+            boolValue(values, "voiceActivityDetectionEnabled") ?? BluetoothSdkDefaults.voiceActivityDetectionEnabled
+        self.values = values
+    }
+
+    public var description: String {
+        "VoiceActivityDetectionStatusEvent(voiceActivityDetectionEnabled: \(voiceActivityDetectionEnabled))"
+    }
+}
+
+public struct SpeakingStatusEvent: CustomStringConvertible {
+    public let speaking: Bool
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        speaking = boolValue(values, "speaking") ?? false
+        self.values = values
+    }
+
+    public var description: String {
+        "SpeakingStatusEvent(speaking: \(speaking))"
+    }
+}
+
+public struct MicHealthEvent: CustomStringConvertible {
+    public let reason: String
+    public let sequenceGapEvents: Int
+    public let decodeFailures: Int
+    public let lastLc3ReceivedAt: Int?
+    public let lastPcmProducedAt: Int?
+    public let timestamp: Int
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        reason = stringValue(values, "reason") ?? ""
+        sequenceGapEvents = intValue(values["sequenceGapEvents"]) ?? 0
+        decodeFailures = intValue(values["decodeFailures"]) ?? 0
+        lastLc3ReceivedAt = intValue(values["lastLc3ReceivedAt"])
+        lastPcmProducedAt = intValue(values["lastPcmProducedAt"])
+        timestamp = intValue(values["timestamp"]) ?? Int(Date().timeIntervalSince1970 * 1000)
+        self.values = values
+    }
+
+    public var description: String {
+        "MicHealthEvent(reason: \(reason), sequenceGapEvents: \(sequenceGapEvents), decodeFailures: \(decodeFailures))"
+    }
+}
+
+public struct OtaStartAckEvent: CustomStringConvertible {
+    public let timestamp: Int?
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        timestamp = intValue(values["timestamp"])
+        self.values = values
+    }
+
+    public var description: String {
+        "OtaStartAckEvent(timestamp: \(timestamp.map(String.init) ?? "unknown"))"
+    }
+}
+
+public struct OtaStatusEvent: CustomStringConvertible {
+    public let sessionId: String
+    public let totalSteps: Int
+    public let currentStep: Int
+    public let stepType: String
+    public let phase: String
+    public let stepPercent: Int
+    public let overallPercent: Int
+    public let status: String
+    public let errorMessage: String?
+    public let glassesTimeMs: Int?
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        sessionId = stringValue(values, "session_id") ?? ""
+        totalSteps = intValue(values["total_steps"]) ?? 0
+        currentStep = intValue(values["current_step"]) ?? 0
+        stepType = stringValue(values, "step_type") ?? ""
+        phase = stringValue(values, "phase") ?? ""
+        stepPercent = intValue(values["step_percent"]) ?? 0
+        overallPercent = intValue(values["overall_percent"]) ?? 0
+        status = stringValue(values, "status") ?? ""
+        errorMessage = stringValue(values, "error_message")
+        glassesTimeMs = intValue(values["glasses_time_ms"])
+        self.values = values
+    }
+
+    public var description: String {
+        "OtaStatusEvent(status: \(status), overallPercent: \(overallPercent))"
+    }
+}
+
+public struct OtaQueryResult: CustomStringConvertible {
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        self.values = values
+    }
+
+    public var type: String {
+        stringValue(values, "type") ?? ""
+    }
+
+    public var status: String? {
+        stringValue(values, "status")
+    }
+
+    public var description: String {
+        "OtaQueryResult(type: \(type), status: \(status ?? "unknown"))"
+    }
+}
+
+public struct SettingsAckEvent: CustomStringConvertible {
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        self.values = values
+    }
+
+    public var requestId: String {
+        stringValue(values, "requestId") ?? ""
+    }
+
+    public var setting: String {
+        stringValue(values, "setting") ?? ""
+    }
+
+    public var status: String {
+        stringValue(values, "status") ?? "applied"
+    }
+
+    public var timestamp: Int {
+        intValue(values["timestamp"]) ?? Int(Date().timeIntervalSince1970 * 1000)
+    }
+
+    public var fov: Int? {
+        intValue(values["fov"])
+    }
+
+    public var roiPosition: Int? {
+        intValue(values["roiPosition"]) ?? intValue(values["roi_position"])
+    }
+
+    public var hardwareApplied: Bool {
+        boolValue(values, "hardwareApplied") ?? boolValue(values, "hardware_applied") ?? false
+    }
+
+    public var errorCode: String? {
+        stringValue(values, "errorCode")
+    }
+
+    public var errorMessage: String? {
+        stringValue(values, "errorMessage")
+    }
+
+    public var description: String {
+        "SettingsAckEvent(setting: \(setting), status: \(status))"
+    }
+}
+
+public struct RgbLedControlResponseEvent: CustomStringConvertible {
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        self.values = values
+    }
+
+    public var requestId: String {
+        stringValue(values, "requestId") ?? ""
+    }
+
+    public var state: String {
+        stringValue(values, "state") ?? "error"
+    }
+
+    public var errorCode: String? {
+        stringValue(values, "errorCode")
+    }
+
+    public var description: String {
+        "RgbLedControlResponseEvent(requestId: \(requestId), state: \(state))"
+    }
+}
+
+public enum BluetoothEvent: CustomStringConvertible {
+    case buttonPress(ButtonPressEvent)
+    case touch(TouchEvent)
+    case voiceActivityDetectionStatus(VoiceActivityDetectionStatusEvent)
+    case speakingStatus(SpeakingStatusEvent)
+    case micHealth(MicHealthEvent)
+    case wifiStatus(WifiStatusEvent)
+    case hotspotStatus(HotspotStatusEvent)
+    case hotspotError(HotspotErrorEvent)
+    case photoResponse(PhotoResponseEvent)
+    case photoStatus(PhotoStatusEvent)
+    case cameraStatus(CameraStatusEvent)
+    case videoRecordingStatus(VideoRecordingStatusEvent)
+    case mediaUpload(MediaUploadEvent)
+    case rgbLedControlResponse(RgbLedControlResponseEvent)
+    case streamStatus(StreamStatusEvent)
+    case keepAliveAck(KeepAliveAckEvent)
+    case otaStartAck(OtaStartAckEvent)
+    case otaStatus(OtaStatusEvent)
+    case settingsAck(SettingsAckEvent)
+    case versionInfo(VersionInfoResult)
+    case localTranscription(LocalTranscriptionEvent)
+    case raw(name: String, values: [String: Any])
+
+    public var description: String {
+        switch self {
+        case let .buttonPress(event):
+            event.description
+        case let .touch(event):
+            event.description
+        case let .voiceActivityDetectionStatus(event):
+            event.description
+        case let .speakingStatus(event):
+            event.description
+        case let .micHealth(event):
+            event.description
+        case let .wifiStatus(event):
+            event.description
+        case let .hotspotStatus(event):
+            event.description
+        case let .hotspotError(event):
+            event.description
+        case let .photoResponse(event):
+            event.description
+        case let .photoStatus(event):
+            event.description
+        case let .cameraStatus(event):
+            event.description
+        case let .videoRecordingStatus(event):
+            event.description
+        case let .mediaUpload(event):
+            event.description
+        case let .rgbLedControlResponse(event):
+            event.description
+        case let .streamStatus(event):
+            event.description
+        case let .keepAliveAck(event):
+            event.description
+        case let .otaStartAck(event):
+            event.description
+        case let .otaStatus(event):
+            event.description
+        case let .settingsAck(event):
+            event.description
+        case let .versionInfo(event):
+            event.description
+        case let .localTranscription(event):
+            event.description
+        case let .raw(name, values):
+            "\(name): \(values)"
+        }
+    }
+}
+
+@MainActor
+public protocol BluetoothSDKDelegate: AnyObject {
+    func bluetoothSDK(_ sdk: BluetoothSDK, didUpdate state: BluetoothState)
+    func bluetoothSDK(_ sdk: BluetoothSDK, didUpdateGlasses glasses: GlassesRuntimeState)
+    func bluetoothSDK(_ sdk: BluetoothSDK, didUpdateSdkState sdkState: PhoneSdkRuntimeState)
+    func bluetoothSDK(_ sdk: BluetoothSDK, didUpdateScan scan: BluetoothScanState)
+    func bluetoothSDK(_ sdk: BluetoothSDK, didDiscover device: Device)
+    func bluetoothSDK(_ sdk: BluetoothSDK, didStopScan reason: ScanStopReason)
+    func bluetoothSDK(_ sdk: BluetoothSDK, didReceive event: BluetoothEvent)
+    func bluetoothSDK(_ sdk: BluetoothSDK, didReceiveMicPcm event: MicPcmEvent)
+    func bluetoothSDK(_ sdk: BluetoothSDK, didReceiveMicLc3 event: MicLc3Event)
+    func bluetoothSDK(_ sdk: BluetoothSDK, didChangeDefaultDevice device: Device?)
+    func bluetoothSDK(_ sdk: BluetoothSDK, didLog message: String)
+    func bluetoothSDK(_ sdk: BluetoothSDK, didFail error: BluetoothSdkError)
+}
+
+@MainActor
+public extension BluetoothSDKDelegate {
+    func bluetoothSDK(_: BluetoothSDK, didUpdate _: BluetoothState) {}
+    func bluetoothSDK(_: BluetoothSDK, didUpdateGlasses _: GlassesRuntimeState) {}
+    func bluetoothSDK(_: BluetoothSDK, didUpdateSdkState _: PhoneSdkRuntimeState) {}
+    func bluetoothSDK(_: BluetoothSDK, didUpdateScan _: BluetoothScanState) {}
+    func bluetoothSDK(_: BluetoothSDK, didDiscover _: Device) {}
+    func bluetoothSDK(_: BluetoothSDK, didStopScan _: ScanStopReason) {}
+    func bluetoothSDK(_: BluetoothSDK, didReceive _: BluetoothEvent) {}
+    func bluetoothSDK(_: BluetoothSDK, didReceiveMicPcm _: MicPcmEvent) {}
+    func bluetoothSDK(_: BluetoothSDK, didReceiveMicLc3 _: MicLc3Event) {}
+    func bluetoothSDK(_: BluetoothSDK, didChangeDefaultDevice _: Device?) {}
+    func bluetoothSDK(_: BluetoothSDK, didLog _: String) {}
+    func bluetoothSDK(_: BluetoothSDK, didFail _: BluetoothSdkError) {}
+}

package/ios/Source/internal/BleTraceLogger.swift

@@ -0,0 +1,192 @@
+import Foundation
+import os.log
+import UIKit
+
+enum BleTraceLogger {
+    private static let log = OSLog(subsystem: "com.glassly.bluetoothsdk", category: "GlasslyBleTrace")
+    private static let maxPayloadChars = 3000
+    private static let k900Type = "k900"
+    private static let sensitiveKeyParts = ["password", "pass", "token", "secret", "authorization", "auth", "email", "serial"]
+
+    static func logJson(
+        direction: String,
+        layer: String,
+        payload: [String: Any]?,
+        bytes: Int? = nil,
+        sourceFile: String = #fileID,
+        sourceFunction: String = #function,
+        sourceLine: Int = #line
+    ) {
+        guard let payload else {
+            emit(format(
+                direction: direction,
+                layer: layer,
+                source: source(file: sourceFile, function: sourceFunction, line: sourceLine),
+                type: "null",
+                bytes: bytes,
+                payload: "null"
+            ))
+            return
+        }
+
+        let sanitized = sanitizeDictionary(payload)
+        emit(format(
+            direction: direction,
+            layer: layer,
+            source: source(file: sourceFile, function: sourceFunction, line: sourceLine),
+            type: extractType(from: payload),
+            bytes: bytes,
+            payload: jsonString(sanitized)
+        ))
+    }
+
+    static func logMap(
+        direction: String,
+        layer: String,
+        type: String?,
+        payload: [String: Any],
+        bytes: Int? = nil,
+        sourceFile: String = #fileID,
+        sourceFunction: String = #function,
+        sourceLine: Int = #line
+    ) {
+        let sanitized = sanitizeDictionary(payload)
+        emit(format(
+            direction: direction,
+            layer: layer,
+            source: source(file: sourceFile, function: sourceFunction, line: sourceLine),
+            type: type ?? extractType(from: sanitized),
+            bytes: bytes,
+            payload: jsonString(sanitized)
+        ))
+    }
+
+    static func logLifecycle(component: String, event: String, extra: [String: Any] = [:]) {
+        var payload: [String: Any] = [
+            "event": event,
+            "component": component,
+            "pid": ProcessInfo.processInfo.processIdentifier,
+            "model": UIDevice.current.model,
+            "systemVersion": UIDevice.current.systemVersion,
+        ]
+        for (key, value) in extra {
+            payload[key] = value
+        }
+        logMap(direction: "phone_app", layer: "app_lifecycle", type: event, payload: payload)
+    }
+
+    private static func emit(_ line: String) {
+        os_log("%{public}@", log: log, type: .info, line)
+    }
+
+    private static func format(
+        direction: String,
+        layer: String,
+        source: String,
+        type: String,
+        bytes: Int?,
+        payload: String
+    ) -> String {
+        let bytesText = bytes.map { " bytes=\($0)" } ?? ""
+        return "BLE_TRACE direction=\(direction) layer=\(layer) source=\(source) type=\(type)\(bytesText) payload=\(truncate(payload))"
+    }
+
+    private static func extractType(from payload: [String: Any]) -> String {
+        if let type = payload["type"] as? String, !type.isEmpty {
+            return type
+        }
+        if let cValue = payload["C"] as? String, !cValue.isEmpty {
+            if let data = cValue.data(using: .utf8),
+               let inner = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+               let type = inner["type"] as? String,
+               !type.isEmpty
+            {
+                return type
+            }
+            return extractK900Type(cValue)
+        }
+        return "unknown"
+    }
+
+    private static func extractK900Type(_ value: String) -> String {
+        value == "sr_log" ? "\(k900Type):sr_log" : k900Type
+    }
+
+    private static func sanitizeDictionary(_ value: [String: Any]) -> [String: Any] {
+        var output: [String: Any] = [:]
+        for (key, child) in value {
+            output[key] = sanitizeValue(key: key, value: child)
+        }
+        return output
+    }
+
+    private static func sanitizeArray(_ value: [Any]) -> [Any] {
+        value.map { sanitizeValue(key: nil, value: $0) }
+    }
+
+    private static func sanitizeValue(key: String?, value: Any) -> Any {
+        if let key, sensitiveKeyParts.contains(where: { key.localizedCaseInsensitiveContains($0) }) {
+            return "<redacted>"
+        }
+
+        if key == "C", let stringValue = value as? String {
+            if let data = stringValue.data(using: .utf8),
+               let parsed = try? JSONSerialization.jsonObject(with: data)
+            {
+                return jsonString(sanitizeJsonValue(parsed))
+            }
+            return sanitizeK900Command(stringValue)
+        }
+
+        return sanitizeJsonValue(value)
+    }
+
+    private static func sanitizeJsonValue(_ value: Any) -> Any {
+        switch value {
+        case let dictionary as [String: Any]:
+            return sanitizeDictionary(dictionary)
+        case let array as [Any]:
+            return sanitizeArray(array)
+        case let data as Data:
+            return "<data \(data.count) bytes>"
+        case let url as URL:
+            return url.absoluteString
+        case let bool as Bool:
+            return bool
+        case let number as NSNumber:
+            return number
+        case let string as String:
+            return string
+        case _ as NSNull:
+            return NSNull()
+        default:
+            return String(describing: value)
+        }
+    }
+
+    private static func sanitizeK900Command(_ value: String) -> String {
+        value == "sr_log" ? value : "<non-json C payload>"
+    }
+
+    private static func jsonString(_ value: Any) -> String {
+        guard JSONSerialization.isValidJSONObject(value),
+              let data = try? JSONSerialization.data(withJSONObject: value),
+              let string = String(data: data, encoding: .utf8)
+        else {
+            return String(describing: value)
+        }
+        return string
+    }
+
+    private static func source(file: String, function: String, line: Int) -> String {
+        "\(function)(\(file):\(line))"
+    }
+
+    private static func truncate(_ value: String) -> String {
+        guard value.count > maxPayloadChars else {
+            return value
+        }
+        let endIndex = value.index(value.startIndex, offsetBy: maxPayloadChars)
+        return "\(value[..<endIndex])...(truncated \(value.count - maxPayloadChars) chars)"
+    }
+}

package/ios/Source/internal/BluetoothAvailability.swift

@@ -0,0 +1,78 @@
+import CoreBluetooth
+import Foundation
+
+final class BluetoothAvailability: NSObject, CBCentralManagerDelegate {
+    static let shared = BluetoothAvailability()
+
+    private var centralManager: CBCentralManager?
+    private var state: CBManagerState = .unknown
+    private var listeners: [UUID: (CBManagerState) -> Void] = [:]
+
+    override private init() {
+        super.init()
+        centralManager = CBCentralManager(
+            delegate: self,
+            queue: .main,
+            options: [CBCentralManagerOptionShowPowerAlertKey: false]
+        )
+        state = centralManager?.state ?? .unknown
+    }
+
+    func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        state = central.state
+        for listener in Array(listeners.values) {
+            listener(state)
+        }
+    }
+
+    @discardableResult
+    func addStateListener(_ listener: @escaping (CBManagerState) -> Void) -> UUID {
+        // `listeners` is unsynchronized; it is only safe because the central
+        // manager queue is `.main` and all callers are main-thread bound.
+        dispatchPrecondition(condition: .onQueue(.main))
+        let id = UUID()
+        listeners[id] = listener
+        listener(state)
+        return id
+    }
+
+    func removeStateListener(_ id: UUID) {
+        dispatchPrecondition(condition: .onQueue(.main))
+        listeners[id] = nil
+    }
+
+    func requirePoweredOn(operation: String) throws {
+        if let current = centralManager?.state {
+            state = current
+        }
+        switch state {
+        case .poweredOn:
+            return
+        case .poweredOff:
+            throw BluetoothSdkError(
+                code: "bluetooth_powered_off",
+                message: "Turn on phone Bluetooth to \(operation)."
+            )
+        case .unauthorized:
+            throw BluetoothSdkError(
+                code: "bluetooth_unauthorized",
+                message: "Allow Bluetooth access to \(operation)."
+            )
+        case .unsupported:
+            throw BluetoothSdkError(
+                code: "bluetooth_unsupported",
+                message: "This phone does not support Bluetooth."
+            )
+        case .resetting, .unknown:
+            throw BluetoothSdkError(
+                code: "bluetooth_not_ready",
+                message: "Bluetooth is not ready yet. Try again."
+            )
+        @unknown default:
+            throw BluetoothSdkError(
+                code: "bluetooth_unavailable",
+                message: "Bluetooth is unavailable. Try again."
+            )
+        }
+    }
+}