@mentra/bluetooth-sdk 0.1.5 → 0.1.6

package/ios/Source/Camera/CameraModels.swift

@@ -0,0 +1,246 @@
+import Foundation
+
+public enum GalleryMode {
+    case auto
+    case manual
+}
+
+public enum PhotoSize: String {
+    case small
+    case medium
+    case large
+    case full
+}
+
+public enum ButtonPhotoSize: String {
+    case small
+    case medium
+    case large
+}
+
+public enum PhotoCompression: String {
+    case none
+    case medium
+    case heavy
+}
+
+public struct ButtonPhotoSettings {
+    public let size: ButtonPhotoSize
+
+    public init(size: ButtonPhotoSize) {
+        self.size = size
+    }
+}
+
+public struct ButtonVideoRecordingSettings {
+    public let width: Int
+    public let height: Int
+    public let frameRate: Int
+
+    public init(width: Int, height: Int, frameRate: Int) {
+        self.width = width
+        self.height = height
+        self.frameRate = frameRate
+    }
+}
+
+public enum CameraFov {
+    case standard
+    case wide
+
+    var value: [String: Int] {
+        switch self {
+        case .standard:
+            ["fov": 118, "roiPosition": 0]
+        case .wide:
+            ["fov": 118, "roiPosition": 0]
+        }
+    }
+}
+
+public struct PhotoRequest {
+    public let requestId: String
+    public let appId: String
+    public let size: PhotoSize
+    public let webhookUrl: String?
+    public let authToken: String?
+    public let compress: PhotoCompression?
+    public let sound: Bool
+
+    public init(
+        requestId: String,
+        appId: String,
+        size: PhotoSize,
+        webhookUrl: String? = nil,
+        authToken: String? = nil,
+        compress: PhotoCompression? = nil,
+        sound: Bool
+    ) {
+        self.requestId = requestId
+        self.appId = appId
+        self.size = size
+        self.webhookUrl = webhookUrl
+        self.authToken = authToken
+        self.compress = compress
+        self.sound = sound
+    }
+}
+
+public enum RgbLedAction: String {
+    case on
+    case off
+}
+
+public enum RgbLedColor: String {
+    case red
+    case green
+    case blue
+    case orange
+    case white
+}
+
+public struct RgbLedRequest {
+    public let requestId: String
+    public let packageName: String?
+    public let action: RgbLedAction
+    public let color: RgbLedColor?
+    public let onDurationMs: Int
+    public let offDurationMs: Int
+    public let count: Int
+
+    public init(
+        requestId: String,
+        packageName: String?,
+        action: RgbLedAction,
+        color: RgbLedColor?,
+        onDurationMs: Int,
+        offDurationMs: Int,
+        count: Int
+    ) {
+        self.requestId = requestId
+        self.packageName = packageName
+        self.action = action
+        self.color = color
+        self.onDurationMs = onDurationMs
+        self.offDurationMs = offDurationMs
+        self.count = count
+    }
+}
+
+public struct VideoRecordingRequest {
+    public let requestId: String
+    public let save: Bool
+    public let sound: Bool
+
+    public init(requestId: String, save: Bool, sound: Bool) {
+        self.requestId = requestId
+        self.save = save
+        self.sound = sound
+    }
+}
+
+public enum PhotoResponse: CustomStringConvertible, Equatable {
+    public enum State: String {
+        case success
+        case error
+    }
+
+    case success(requestId: String, uploadUrl: String, timestamp: Int)
+    case error(requestId: String, errorCode: String?, errorMessage: String, timestamp: Int)
+
+    public init(values: [String: Any]) {
+        let requestId = stringValue(values, "requestId") ?? ""
+        let timestamp = intValue(values["timestamp"]) ?? Int(Date().timeIntervalSince1970 * 1000)
+        let state = stringValue(values, "state")?.lowercased()
+        if state == State.success.rawValue {
+            self = .success(
+                requestId: requestId,
+                uploadUrl: stringValue(values, "uploadUrl") ?? "",
+                timestamp: timestamp
+            )
+        } else {
+            self = .error(
+                requestId: requestId,
+                errorCode: stringValue(values, "errorCode"),
+                errorMessage: stringValue(values, "errorMessage") ?? "Unknown photo error",
+                timestamp: timestamp
+            )
+        }
+    }
+
+    public var state: State {
+        switch self {
+        case .success:
+            .success
+        case .error:
+            .error
+        }
+    }
+
+    public var requestId: String {
+        switch self {
+        case let .success(requestId, _, _), let .error(requestId, _, _, _):
+            requestId
+        }
+    }
+
+    public var timestamp: Int {
+        switch self {
+        case let .success(_, _, timestamp), let .error(_, _, _, timestamp):
+            timestamp
+        }
+    }
+
+    public var values: [String: Any] {
+        switch self {
+        case let .success(requestId, uploadUrl, timestamp):
+            return [
+                "state": State.success.rawValue,
+                "requestId": requestId,
+                "uploadUrl": uploadUrl,
+                "timestamp": timestamp,
+            ]
+        case let .error(requestId, errorCode, errorMessage, timestamp):
+            var values: [String: Any] = [
+                "state": State.error.rawValue,
+                "requestId": requestId,
+                "errorMessage": errorMessage,
+                "timestamp": timestamp,
+            ]
+            if let errorCode, !errorCode.isEmpty {
+                values["errorCode"] = errorCode
+            }
+            return values
+        }
+    }
+
+    public var description: String {
+        "PhotoResponse(requestId: \(requestId), state: \(state.rawValue))"
+    }
+}
+
+public struct PhotoResponseEvent: CustomStringConvertible {
+    public let response: PhotoResponse
+
+    public init(response: PhotoResponse) {
+        self.response = response
+    }
+
+    public init(values: [String: Any]) {
+        self.response = PhotoResponse(values: values)
+    }
+
+    public var requestId: String {
+        response.requestId
+    }
+
+    public var values: [String: Any] {
+        var values = response.values
+        values["type"] = "photo_response"
+        return values
+    }
+
+    public var description: String {
+        "PhotoResponseEvent(requestId: \(requestId), state: \(response.state.rawValue))"
+    }
+}

package/ios/Source/Connection/ScanSession.swift

@@ -0,0 +1,27 @@
+import Foundation
+
+public enum ScanStopReason {
+    case completed
+    case cancelled
+    case error
+}
+
+@MainActor
+public final class ScanSession {
+    private let stopAction: () -> Void
+    private var stopped = false
+
+    init(stopAction: @escaping () -> Void) {
+        self.stopAction = stopAction
+    }
+
+    public func stop() {
+        guard !stopped else { return }
+        stopped = true
+        stopAction()
+    }
+
+    func markStopped() {
+        stopped = true
+    }
+}

package/ios/Source/DeviceStore.swift

@@ -97,6 +97,7 @@ class DeviceStore {
         store.set("bluetooth", "should_send_lc3", false)
         store.set("bluetooth", "should_send_transcript", false)
         store.set("bluetooth", "bypass_vad", true)
+        store.set("bluetooth", "use_native_dashboard", false)
     }
 
     func get(_ category: String, _ key: String) -> Any? {

package/ios/Source/Errors/BluetoothError.swift

@@ -0,0 +1,19 @@
+import Foundation
+
+public struct BluetoothError: 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,115 @@
+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 enum BluetoothEvent: CustomStringConvertible {
+    case buttonPress(ButtonPressEvent)
+    case touch(TouchEvent)
+    case wifiStatus(WifiStatusEvent)
+    case hotspotStatus(HotspotStatusEvent)
+    case hotspotError(HotspotErrorEvent)
+    case photoResponse(PhotoResponseEvent)
+    case streamStatus(StreamStatusEvent)
+    case keepAliveAck(KeepAliveAckEvent)
+    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 .wifiStatus(event):
+            event.description
+        case let .hotspotStatus(event):
+            event.description
+        case let .hotspotError(event):
+            event.description
+        case let .photoResponse(event):
+            event.description
+        case let .streamStatus(event):
+            event.description
+        case let .keepAliveAck(event):
+            event.description
+        case let .localTranscription(event):
+            event.description
+        case let .raw(name, values):
+            "\(name): \(values)"
+        }
+    }
+}
+
+@MainActor
+public protocol MentraBluetoothSDKDelegate: AnyObject {
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didUpdate state: MentraBluetoothState)
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didUpdateGlasses glasses: GlassesRuntimeState)
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didUpdateSdkState sdkState: PhoneSdkRuntimeState)
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didUpdateScan scan: BluetoothScanState)
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didDiscover device: Device)
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didStopScan reason: ScanStopReason)
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didReceive event: BluetoothEvent)
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didReceiveMicPcm event: MicPcmEvent)
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didReceiveMicLc3 event: MicLc3Event)
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didChangeDefaultDevice device: Device?)
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didLog message: String)
+    func mentraBluetoothSDK(_ sdk: MentraBluetoothSDK, didFail error: BluetoothError)
+}
+
+@MainActor
+public extension MentraBluetoothSDKDelegate {
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didUpdate _: MentraBluetoothState) {}
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didUpdateGlasses _: GlassesRuntimeState) {}
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didUpdateSdkState _: PhoneSdkRuntimeState) {}
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didUpdateScan _: BluetoothScanState) {}
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didDiscover _: Device) {}
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didStopScan _: ScanStopReason) {}
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didReceive _: BluetoothEvent) {}
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didReceiveMicPcm _: MicPcmEvent) {}
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didReceiveMicLc3 _: MicLc3Event) {}
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didChangeDefaultDevice _: Device?) {}
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didLog _: String) {}
+    func mentraBluetoothSDK(_: MentraBluetoothSDK, didFail _: BluetoothError) {}
+}

package/ios/Source/Internal/BluetoothAvailability.swift

@@ -0,0 +1,58 @@
+import CoreBluetooth
+import Foundation
+
+final class BluetoothAvailability: NSObject, CBCentralManagerDelegate {
+    static let shared = BluetoothAvailability()
+
+    private var centralManager: CBCentralManager?
+    private var state: CBManagerState = .unknown
+
+    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
+    }
+
+    func requirePoweredOn(operation: String) throws {
+        if let current = centralManager?.state {
+            state = current
+        }
+        switch state {
+        case .poweredOn:
+            return
+        case .poweredOff:
+            throw BluetoothError(
+                code: "bluetooth_powered_off",
+                message: "Turn on phone Bluetooth to \(operation)."
+            )
+        case .unauthorized:
+            throw BluetoothError(
+                code: "bluetooth_unauthorized",
+                message: "Allow Bluetooth access to \(operation)."
+            )
+        case .unsupported:
+            throw BluetoothError(
+                code: "bluetooth_unsupported",
+                message: "This phone does not support Bluetooth."
+            )
+        case .resetting, .unknown:
+            throw BluetoothError(
+                code: "bluetooth_not_ready",
+                message: "Bluetooth is not ready yet. Try again."
+            )
+        @unknown default:
+            throw BluetoothError(
+                code: "bluetooth_unavailable",
+                message: "Bluetooth is unavailable. Try again."
+            )
+        }
+    }
+}

package/ios/Source/Internal/ValueParsing.swift

@@ -0,0 +1,90 @@
+import Foundation
+
+func intValue(_ value: Any?) -> Int? {
+    if let int = value as? Int { return int }
+    if let double = value as? Double { return Int(double) }
+    if let number = value as? NSNumber { return number.intValue }
+    return nil
+}
+
+func stringValue(_ values: [String: Any], _ keys: String...) -> String? {
+    stringValue(values, keys)
+}
+
+func stringValue(_ values: [String: Any], _ keys: [String]) -> String? {
+    for key in keys {
+        if let value = values[key] as? String {
+            return value
+        }
+    }
+    return nil
+}
+
+func boolValue(_ values: [String: Any], _ keys: String...) -> Bool? {
+    boolValue(values, keys)
+}
+
+func boolValue(_ values: [String: Any], _ keys: [String]) -> Bool? {
+    for key in keys {
+        if let value = values[key] as? Bool { return value }
+        if let value = values[key] as? NSNumber { return value.boolValue }
+    }
+    return nil
+}
+
+func hasAnyKey(_ values: [String: Any], _ keys: String...) -> Bool {
+    hasAnyKey(values, keys)
+}
+
+func hasAnyKey(_ values: [String: Any], _ keys: [String]) -> Bool {
+    keys.contains { values.keys.contains($0) }
+}
+
+func optionalStringValue(_ values: [String: Any], _ keys: String...) -> String? {
+    hasAnyKey(values, keys) ? stringValue(values, keys) : nil
+}
+
+func nonEmptyStringValue(_ values: [String: Any], _ keys: String...) -> String? {
+    for key in keys {
+        guard let value = values[key] as? String else { continue }
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        if !trimmed.isEmpty {
+            return value
+        }
+    }
+    return nil
+}
+
+func optionalIntValue(_ values: [String: Any], _ keys: String...) -> Int? {
+    guard hasAnyKey(values, keys) else { return nil }
+    for key in keys {
+        if let value = intValue(values[key]) { return value }
+    }
+    return nil
+}
+
+func optionalBoolValue(_ values: [String: Any], _ keys: String...) -> Bool? {
+    hasAnyKey(values, keys) ? boolValue(values, keys) : nil
+}
+
+func stringListValue(_ values: [String: Any], _ key: String) -> [String] {
+    values[key] as? [String] ?? []
+}
+
+func optionalStringListValue(_ values: [String: Any], _ key: String) -> [String]? {
+    values.keys.contains(key) ? stringListValue(values, key) : nil
+}
+
+func dictionaryListValue(_ values: [String: Any], _ key: String) -> [[String: Any]] {
+    values[key] as? [[String: Any]] ?? []
+}
+
+func optionalDictionaryListValue(_ values: [String: Any], _ key: String) -> [[String: Any]]? {
+    values.keys.contains(key) ? dictionaryListValue(values, key) : nil
+}
+
+func putIfNotNil(_ map: inout [String: Any], _ key: String, _ value: Any?) {
+    if let value {
+        map[key] = value
+    }
+}