@glassly/bluetooth-sdk 0.1.0-dev.26

package/ios/Source/status/RuntimeState.swift

@@ -0,0 +1,359 @@
+import Foundation
+
+public struct BluetoothState: CustomStringConvertible {
+    public let glasses: GlassesRuntimeState
+    public let sdk: PhoneSdkRuntimeState
+    public let scan: BluetoothScanState
+
+    public init(glasses: GlassesRuntimeState, sdk: PhoneSdkRuntimeState, scan: BluetoothScanState) {
+        self.glasses = glasses
+        self.sdk = sdk
+        self.scan = scan
+    }
+
+    init(glassesStatus: GlassesStatus, bluetoothStatus: BluetoothStatus) {
+        glasses = GlassesRuntimeState(status: glassesStatus)
+        sdk = PhoneSdkRuntimeState(status: bluetoothStatus)
+        scan = BluetoothScanState(status: bluetoothStatus)
+    }
+
+    public var description: String {
+        "BluetoothState(glasses: \(glasses), scan: \(scan))"
+    }
+}
+
+public struct GlassesBatteryState: Equatable, CustomStringConvertible {
+    public let charging: Bool
+    public let level: Int?
+
+    public init(charging: Bool, level: Int?) {
+        self.charging = charging
+        self.level = level
+    }
+
+    public var description: String {
+        "GlassesBatteryState(level: \(level.map(String.init) ?? "unknown"), charging: \(charging))"
+    }
+}
+
+public struct ConnectedGlassesInfo: Equatable, CustomStringConvertible {
+    public let appVersion: String?
+    public let bluetoothName: String?
+    public let buildNumber: String?
+    public let color: String?
+    public let deviceModel: DeviceModel?
+    public let firmwareVersion: String?
+    public let serialNumber: String?
+    public let style: String?
+
+    public init(
+        appVersion: String?,
+        bluetoothName: String?,
+        buildNumber: String?,
+        color: String?,
+        deviceModel: DeviceModel?,
+        firmwareVersion: String?,
+        serialNumber: String?,
+        style: String?
+    ) {
+        self.appVersion = appVersion
+        self.bluetoothName = bluetoothName
+        self.buildNumber = buildNumber
+        self.color = color
+        self.deviceModel = deviceModel
+        self.firmwareVersion = firmwareVersion
+        self.serialNumber = serialNumber
+        self.style = style
+    }
+
+    public var description: String {
+        bluetoothName ?? serialNumber ?? deviceModel?.deviceType ?? "Connected glasses"
+    }
+}
+
+public enum FirmwareSource: String {
+    case app
+    case bes
+    case firmware
+    case mtk
+    case unknown
+}
+
+public struct FirmwareInfo: Equatable, CustomStringConvertible {
+    public let appVersion: String?
+    public let buildNumber: String?
+    public let source: FirmwareSource
+    public let version: String?
+
+    public init(appVersion: String?, buildNumber: String?, source: FirmwareSource, version: String?) {
+        self.appVersion = appVersion
+        self.buildNumber = buildNumber
+        self.source = source
+        self.version = version
+    }
+
+    public var description: String {
+        version ?? "Unknown firmware"
+    }
+}
+
+public struct SignalState: Equatable, CustomStringConvertible {
+    public let strengthDbm: Int?
+    public let updatedAt: Int?
+
+    public init(strengthDbm: Int?, updatedAt: Int?) {
+        self.strengthDbm = strengthDbm
+        self.updatedAt = updatedAt
+    }
+
+    public var description: String {
+        strengthDbm.map { "\($0) dBm" } ?? "Unknown signal"
+    }
+}
+
+public enum GlassesRuntimeState: CustomStringConvertible {
+    case disconnected(connection: GlassesConnectionState)
+    case connected(
+        battery: GlassesBatteryState,
+        connection: GlassesConnectionState,
+        device: ConnectedGlassesInfo,
+        firmware: FirmwareInfo,
+        hotspot: HotspotStatus,
+        ready: Bool,
+        signal: SignalState,
+        voiceActivityDetectionEnabled: Bool,
+        wifi: WifiStatus
+    )
+
+    init(status: GlassesStatus) {
+        if !status.connected, status.connectionState != .connected {
+            self = .disconnected(connection: status.connectionState)
+            return
+        }
+
+        self = .connected(
+            battery: GlassesBatteryState(
+                charging: status.charging,
+                level: status.batteryLevel >= 0 ? status.batteryLevel : nil
+            ),
+            connection: .connected,
+            device: ConnectedGlassesInfo(
+                appVersion: status.appVersion.nonEmpty,
+                bluetoothName: status.bluetoothName.nonEmpty,
+                buildNumber: status.buildNumber.nonEmpty,
+                color: status.color.nonEmpty,
+                deviceModel: status.deviceModel.nonEmpty.map(DeviceModel.fromDeviceType),
+                firmwareVersion: status.firmwareVersion.nonEmpty,
+                serialNumber: status.serialNumber.nonEmpty,
+                style: status.style.nonEmpty
+            ),
+            firmware: FirmwareInfo(status: status),
+            hotspot: status.hotspot,
+            ready: status.fullyBooted,
+            signal: SignalState(
+                strengthDbm: status.signalStrength == -1 ? nil : status.signalStrength,
+                updatedAt: status.signalStrengthUpdatedAt <= 0 ? nil : status.signalStrengthUpdatedAt
+            ),
+            voiceActivityDetectionEnabled: status.voiceActivityDetectionEnabled,
+            wifi: status.wifi
+        )
+    }
+
+    public var connected: Bool {
+        if case .connected = self {
+            return true
+        }
+        return false
+    }
+
+    public var connection: GlassesConnectionState {
+        switch self {
+        case let .disconnected(connection):
+            connection
+        case let .connected(_, connection, _, _, _, _, _, _, _):
+            connection
+        }
+    }
+
+    public var ready: Bool {
+        switch self {
+        case .disconnected:
+            false
+        case let .connected(_, _, _, _, _, ready, _, _, _):
+            ready
+        }
+    }
+
+    public var battery: GlassesBatteryState? {
+        guard case let .connected(battery, _, _, _, _, _, _, _, _) = self else {
+            return nil
+        }
+        return battery
+    }
+
+    public var device: ConnectedGlassesInfo? {
+        guard case let .connected(_, _, device, _, _, _, _, _, _) = self else {
+            return nil
+        }
+        return device
+    }
+
+    public var firmware: FirmwareInfo? {
+        guard case let .connected(_, _, _, firmware, _, _, _, _, _) = self else {
+            return nil
+        }
+        return firmware
+    }
+
+    public var hotspot: HotspotStatus? {
+        guard case let .connected(_, _, _, _, hotspot, _, _, _, _) = self else {
+            return nil
+        }
+        return hotspot
+    }
+
+    public var signal: SignalState? {
+        guard case let .connected(_, _, _, _, _, _, signal, _, _) = self else {
+            return nil
+        }
+        return signal
+    }
+
+    public var voiceActivityDetectionEnabled: Bool {
+        guard case let .connected(_, _, _, _, _, _, _, voiceActivityDetectionEnabled, _) = self else {
+            return false
+        }
+        return voiceActivityDetectionEnabled
+    }
+
+    public var wifi: WifiStatus? {
+        guard case let .connected(_, _, _, _, _, _, _, _, wifi) = self else {
+            return nil
+        }
+        return wifi
+    }
+
+    public var description: String {
+        switch self {
+        case let .disconnected(connection):
+            "GlassesRuntimeState(\(connection.rawValue))"
+        case let .connected(_, _, device, _, _, ready, _, _, _):
+            "GlassesRuntimeState(connected: \(device), ready: \(ready))"
+        }
+    }
+}
+
+public struct GalleryModeState: Equatable {
+    public let enabled: Bool
+
+    public init(enabled: Bool) {
+        self.enabled = enabled
+    }
+}
+
+public enum MicMode: String {
+    case phone
+    case glasses
+    case bluetoothClassic
+    case bluetooth
+}
+
+public struct PhoneSdkRuntimeState: CustomStringConvertible {
+    public let currentMic: MicMode?
+    public let defaultDevice: Device?
+    public let galleryMode: GalleryModeState
+    public let lastLog: [String]
+    public let micRanking: [MicMode]
+    public let otherBluetoothConnected: Bool
+    public let searching: Bool
+    public let searchingController: Bool
+    public let systemMicUnavailable: Bool
+    public let wifiScanResults: [WifiScanResult]
+
+    public init(
+        currentMic: MicMode?,
+        defaultDevice: Device?,
+        galleryMode: GalleryModeState,
+        lastLog: [String],
+        micRanking: [MicMode],
+        otherBluetoothConnected: Bool,
+        searching: Bool,
+        searchingController: Bool,
+        systemMicUnavailable: Bool,
+        wifiScanResults: [WifiScanResult]
+    ) {
+        self.currentMic = currentMic
+        self.defaultDevice = defaultDevice
+        self.galleryMode = galleryMode
+        self.lastLog = lastLog
+        self.micRanking = micRanking
+        self.otherBluetoothConnected = otherBluetoothConnected
+        self.searching = searching
+        self.searchingController = searchingController
+        self.systemMicUnavailable = systemMicUnavailable
+        self.wifiScanResults = wifiScanResults
+    }
+
+    init(status: BluetoothStatus) {
+        currentMic = MicMode(rawValue: status.currentMic)
+        defaultDevice = status.defaultDevice
+        galleryMode = GalleryModeState(enabled: status.galleryModeEnabled)
+        lastLog = status.lastLog
+        micRanking = status.micRanking.compactMap(MicMode.init(rawValue:))
+        otherBluetoothConnected = status.otherBtConnected
+        searching = status.searching
+        searchingController = status.searchingController
+        systemMicUnavailable = status.systemMicUnavailable
+        wifiScanResults = status.wifiScanResults
+    }
+
+    public var description: String {
+        "PhoneSdkRuntimeState(searching: \(searching), currentMic: \(currentMic?.rawValue ?? "unknown"))"
+    }
+}
+
+public struct BluetoothScanState: CustomStringConvertible {
+    public let active: Bool
+    public let devices: [Device]
+    public let searchingController: Bool
+
+    public init(active: Bool, devices: [Device], searchingController: Bool) {
+        self.active = active
+        self.devices = devices
+        self.searchingController = searchingController
+    }
+
+    init(status: BluetoothStatus) {
+        active = status.searching
+        devices = status.searchResults
+        searchingController = status.searchingController
+    }
+
+    public var description: String {
+        "BluetoothScanState(active: \(active), devices: \(devices.count))"
+    }
+}
+
+private extension FirmwareInfo {
+    init(status: GlassesStatus) {
+        let sources: [(String, FirmwareSource)] = [
+            (status.firmwareVersion, .firmware),
+            (status.besFirmwareVersion, .bes),
+            (status.mtkFirmwareVersion, .mtk),
+            (status.appVersion, .app),
+        ]
+        let match = sources.first { !$0.0.isEmpty }
+        self.init(
+            appVersion: status.appVersion.nonEmpty,
+            buildNumber: status.buildNumber.nonEmpty,
+            source: match?.1 ?? .unknown,
+            version: match?.0.nonEmpty
+        )
+    }
+}
+
+private extension String {
+    var nonEmpty: String? {
+        isEmpty ? nil : self
+    }
+}

package/ios/Source/status/WifiHotspotStatus.swift

@@ -0,0 +1,345 @@
+import Foundation
+
+public enum WifiStatus: CustomStringConvertible, Equatable {
+    public enum State: String {
+        case disconnected
+        case connected
+    }
+
+    case disconnected
+    case connected(ssid: String, localIp: String?)
+
+    private init?(connected: Bool, ssid: String?, localIp: String?) {
+        if connected {
+            guard
+                let ssid = ssid?.trimmingCharacters(in: .whitespacesAndNewlines),
+                !ssid.isEmpty
+            else {
+                return nil
+            }
+            let trimmedLocalIp = localIp?.trimmingCharacters(in: .whitespacesAndNewlines)
+            self = .connected(
+                ssid: ssid,
+                localIp: trimmedLocalIp?.isEmpty == false ? trimmedLocalIp : nil
+            )
+        } else {
+            self = .disconnected
+        }
+    }
+
+    init?(values: [String: Any]) {
+        if let nested = values["wifi"] as? [String: Any] {
+            guard let wifi = WifiStatus(values: nested) else {
+                return nil
+            }
+            self = wifi
+            return
+        }
+
+        if let state = stringValue(values, "state")?.lowercased() {
+            switch state {
+            case State.connected.rawValue:
+                guard let wifi = WifiStatus(
+                    connected: true,
+                    ssid: nonEmptyStringValue(values, "ssid"),
+                    localIp: nonEmptyStringValue(values, "localIp")
+                ) else {
+                    return nil
+                }
+                self = wifi
+            case State.disconnected.rawValue:
+                self = .disconnected
+            default:
+                return nil
+            }
+            return
+        }
+
+        return nil
+    }
+
+    static func fromStoreValues(_ values: [String: Any]) -> WifiStatus? {
+        guard let connected = boolValue(values, "wifiConnected") else { return nil }
+        return fromStoreFields(
+            connected: connected,
+            ssid: nonEmptyStringValue(values, "wifiSsid"),
+            localIp: nonEmptyStringValue(values, "wifiLocalIp")
+        )
+    }
+
+    static func fromStoreFields(connected: Bool, ssid: String?, localIp: String?) -> WifiStatus? {
+        WifiStatus(connected: connected, ssid: ssid, localIp: localIp)
+    }
+
+    public var state: State {
+        switch self {
+        case .disconnected:
+            .disconnected
+        case .connected:
+            .connected
+        }
+    }
+
+    public var isConnected: Bool {
+        if case .connected = self {
+            return true
+        }
+        return false
+    }
+
+    public var values: [String: Any] {
+        switch self {
+        case .disconnected:
+            return ["state": State.disconnected.rawValue]
+        case let .connected(ssid, localIp):
+            var values: [String: Any] = [
+                "state": State.connected.rawValue,
+                "ssid": ssid,
+            ]
+            if let localIp = localIp {
+                values["localIp"] = localIp
+            }
+            return values
+        }
+    }
+
+    var storeValues: [String: Any] {
+        switch self {
+        case .disconnected:
+            [
+                "wifiConnected": false,
+                "wifiSsid": "",
+                "wifiLocalIp": "",
+            ]
+        case let .connected(ssid, localIp):
+            [
+                "wifiConnected": true,
+                "wifiSsid": ssid,
+                "wifiLocalIp": localIp ?? "",
+            ]
+        }
+    }
+
+    public var description: String {
+        switch self {
+        case .disconnected:
+            "WifiStatus(disconnected)"
+        case let .connected(ssid, localIp):
+            "WifiStatus(connected: \(ssid), localIp: \(localIp ?? "unknown"))"
+        }
+    }
+}
+
+public struct WifiStatusEvent: CustomStringConvertible {
+    public let status: WifiStatus
+
+    /// Glasses-reported provisioning failure reason when THIS event is the verdict of a
+    /// failed connect attempt; nil for routine link-state updates. An attempt property,
+    /// not a link property — which is why it lives on the event and not on `WifiStatus`:
+    /// "connect_timeout" arrives with a disconnected status (never associated), while
+    /// "connected_to_other_network" arrives with a *connected* status — the attempt
+    /// failed and Android's auto-join left the glasses on (or returned them to) a
+    /// different SSID than requested, so the link is genuinely up while the request
+    /// genuinely failed. Sent by ASG client builds that include the WiFi error
+    /// surfacing (v40+); older glasses never set it.
+    public let error: String?
+
+    public init(status: WifiStatus, error: String? = nil) {
+        self.status = status
+        self.error = error
+    }
+
+    init(connected: Bool, ssid: String?, localIp: String?) {
+        status = WifiStatus.fromStoreFields(connected: connected, ssid: ssid, localIp: localIp) ?? .disconnected
+        error = nil
+    }
+
+    init(values: [String: Any]) {
+        status = WifiStatus(values: values) ?? .disconnected
+        let rawError = stringValue(values, "error")
+        error = rawError?.isEmpty == false ? rawError : nil
+    }
+
+    public var values: [String: Any] {
+        var body = status.values.merging(["type": "wifi_status_change"]) { _, new in new }
+        if let error {
+            body["error"] = error
+        }
+        return body
+    }
+
+    public var description: String {
+        "WifiStatusEvent(\(status))"
+    }
+}
+
+public enum HotspotStatus: CustomStringConvertible, Equatable {
+    public enum State: String {
+        case disabled
+        case enabled
+    }
+
+    case disabled
+    case enabled(ssid: String, password: String, localIp: String)
+
+    public init?(enabled: Bool, ssid: String?, password: String?, localIp: String?) {
+        if enabled {
+            guard
+                let ssid = ssid?.trimmingCharacters(in: .whitespacesAndNewlines),
+                !ssid.isEmpty,
+                let password = password?.trimmingCharacters(in: .whitespacesAndNewlines),
+                !password.isEmpty,
+                let localIp = localIp?.trimmingCharacters(in: .whitespacesAndNewlines),
+                !localIp.isEmpty
+            else {
+                return nil
+            }
+            self = .enabled(ssid: ssid, password: password, localIp: localIp)
+        } else {
+            self = .disabled
+        }
+    }
+
+    public init?(values: [String: Any]) {
+        if let nested = values["hotspot"] as? [String: Any] {
+            self.init(values: nested)
+            return
+        }
+
+        guard let state = stringValue(values, "state")?.lowercased() else {
+            return nil
+        }
+
+        switch state {
+        case State.enabled.rawValue:
+            self.init(
+                enabled: true,
+                ssid: nonEmptyStringValue(values, "ssid"),
+                password: nonEmptyStringValue(values, "password"),
+                localIp: nonEmptyStringValue(values, "localIp")
+            )
+        case State.disabled.rawValue:
+            self = .disabled
+        default:
+            return nil
+        }
+    }
+
+    static func fromStoreValues(_ values: [String: Any]) -> HotspotStatus? {
+        guard let enabled = boolValue(values, "hotspotEnabled") else {
+            return nil
+        }
+        return fromStoreFields(
+            enabled: enabled,
+            ssid: nonEmptyStringValue(values, "hotspotSsid"),
+            password: nonEmptyStringValue(values, "hotspotPassword"),
+            localIp: nonEmptyStringValue(values, "hotspotGatewayIp")
+        )
+    }
+
+    static func fromStoreFields(enabled: Bool, ssid: String?, password: String?, localIp: String?) -> HotspotStatus? {
+        HotspotStatus(enabled: enabled, ssid: ssid, password: password, localIp: localIp)
+    }
+
+    var storeValues: [String: Any] {
+        switch self {
+        case .disabled:
+            [
+                "hotspotEnabled": false,
+                "hotspotSsid": "",
+                "hotspotPassword": "",
+                "hotspotGatewayIp": "",
+            ]
+        case let .enabled(ssid, password, localIp):
+            [
+                "hotspotEnabled": true,
+                "hotspotSsid": ssid,
+                "hotspotPassword": password,
+                "hotspotGatewayIp": localIp,
+            ]
+        }
+    }
+
+    public var values: [String: Any] {
+        switch self {
+        case .disabled:
+            ["state": State.disabled.rawValue]
+        case let .enabled(ssid, password, localIp):
+            [
+                "state": State.enabled.rawValue,
+                "ssid": ssid,
+                "password": password,
+                "localIp": localIp,
+            ]
+        }
+    }
+
+    public var state: State {
+        switch self {
+        case .disabled:
+            .disabled
+        case .enabled:
+            .enabled
+        }
+    }
+
+    public var isEnabled: Bool {
+        if case .enabled = self {
+            return true
+        }
+        return false
+    }
+
+    public var description: String {
+        switch self {
+        case .disabled:
+            "HotspotStatus(disabled)"
+        case let .enabled(ssid, _, localIp):
+            "HotspotStatus(enabled: \(ssid), localIp: \(localIp))"
+        }
+    }
+}
+
+public struct HotspotStatusEvent: CustomStringConvertible {
+    public let status: HotspotStatus
+
+    public init(status: HotspotStatus) {
+        self.status = status
+    }
+
+    init(enabled: Bool, ssid: String?, password: String?, localIp: String?) {
+        status = HotspotStatus.fromStoreFields(enabled: enabled, ssid: ssid, password: password, localIp: localIp) ?? .disabled
+    }
+
+    init(values: [String: Any]) {
+        status = HotspotStatus(values: values) ?? .disabled
+    }
+
+    public var values: [String: Any] {
+        status.values.merging(["type": "hotspot_status_change"]) { _, new in new }
+    }
+
+    public var description: String {
+        "HotspotStatusEvent(\(status))"
+    }
+}
+
+public struct HotspotErrorEvent: CustomStringConvertible {
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        self.values = values
+    }
+
+    public var message: String? {
+        stringValue(values, "errorMessage")
+    }
+
+    public var timestamp: Int? {
+        intValue(values["timestamp"])
+    }
+
+    public var description: String {
+        "HotspotErrorEvent(message: \(message ?? "unknown"))"
+    }
+}