@glassly/bluetooth-sdk 0.1.0-dev.26

package/ios/Source/utils/BleJsonCompact.swift

@@ -0,0 +1,405 @@
+import Foundation
+
+/// BLE Wire Protocol v2 JSON compaction with lossless fallback for ambiguous payloads.
+enum BleJsonCompact {
+    static let keyResolvedConfigHash = "rch"
+
+    private static let longToShort: [String: String] = [
+        "type": "t",
+        "requestId": "r",
+        "timestamp": "ts",
+        "status": "s",
+        "kind": "k",
+        "source": "src",
+        "requestedCaptureConfig": "rcc",
+        "meteredPreview": "mp",
+        "exposureTimeNs": "etn",
+        "captureMetadata": "cm",
+        "aeStateName": "aes",
+        "transferMethod": "tm",
+        "manual": "m",
+        "reconnecting": "rc",
+        "stats": "st",
+        "width": "w",
+        "height": "h",
+        "bitrate": "br",
+        "fps": "f",
+        "droppedFrames": "df",
+        "duration": "du",
+        "temperatureC": "tc",
+    ]
+
+    private static let shortToLong: [String: String] = {
+        var map: [String: String] = [:]
+        for (longKey, shortKey) in longToShort {
+            map[shortKey] = longKey
+        }
+        return map
+    }()
+
+    private static let photoStatusToInt: [String: Int] = [
+        "accepted": 0, "queued": 1, "configuring": 2, "capturing": 3,
+        "captured": 4, "uploading": 5, "uploaded": 6, "failed": 7,
+    ]
+    private static let photoStatusFromInt: [Int: String] = {
+        var map: [Int: String] = [:]
+        for (key, value) in photoStatusToInt { map[value] = key }
+        return map
+    }()
+
+    private static let kindToInt = ["lifecycle": 0, "snapshot": 1]
+    private static let kindFromInt: [Int: String] = [0: "lifecycle", 1: "snapshot"]
+
+    private static let sourceToInt = ["sdk": 0, "button": 1]
+    private static let sourceFromInt: [Int: String] = [0: "sdk", 1: "button"]
+
+    private static let aeStateToInt: [String: Int] = [
+        "CONVERGED": 0, "SEARCHING": 1, "INACTIVE": 2,
+        "LOCKED": 3, "FLASH_REQUIRED": 4, "PRECAPTURE": 5,
+    ]
+    private static let aeStateFromInt: [Int: String] = {
+        var map: [Int: String] = [:]
+        for (key, value) in aeStateToInt { map[value] = key }
+        return map
+    }()
+
+    private static var sessionConnectEpochMs: Int64 = 0
+    private static var resolvedConfigByHash: [String: [String: Any]] = [:]
+
+    private static let highRoiMessageTypes: Set<String> = [
+        "photo_status",
+        "stream_status",
+        "wifi_scan_result",
+        "start_stream",
+        "photo_response",
+    ]
+
+    private static let chunkMessageTypes: Set<String> = ["ck", "chunked_msg"]
+
+    static func shouldCompactOutbound(_ messageType: String) -> Bool {
+        highRoiMessageTypes.contains(messageType)
+    }
+
+    static func supportsCompactInbound(_ messageType: String) -> Bool {
+        !messageType.isEmpty
+            && (highRoiMessageTypes.contains(messageType) || chunkMessageTypes.contains(messageType))
+    }
+
+    static func isCompactWireForm(_ json: [String: Any]) -> Bool {
+        json["t"] != nil && json["type"] == nil
+    }
+
+    static func extractMessageType(_ json: [String: Any]) -> String {
+        if let type = stringValue(json["type"]) {
+            return type
+        }
+        if let compactType = stringValue(json["t"]) {
+            return compactType
+        }
+        return ""
+    }
+
+    static func resetSession() {
+        sessionConnectEpochMs = 0
+        resolvedConfigByHash.removeAll()
+    }
+
+    static func markSessionConnected(epochMs: Int64) {
+        resetSession()
+        sessionConnectEpochMs = epochMs
+    }
+
+    static func isCameraCommandJson(_ jsonData: String) -> Bool {
+        jsonData.contains("cs_pho")
+            || jsonData.contains("cs_cpho")
+            || jsonData.contains("cs_vid")
+            || jsonData.contains("\"type\":\"take_photo\"")
+    }
+
+    static func encode(_ json: [String: Any]) -> [String: Any] {
+        if isCameraCommandJson(jsonString(json) ?? "") {
+            return json
+        }
+        let messageType = extractMessageType(json)
+        if !shouldCompactOutbound(messageType) || !canCompactLosslessly(json, topLevel: true) {
+            return json
+        }
+        return compactObject(json, topLevel: true)
+    }
+
+    static func encode(jsonString: String) -> [String: Any]? {
+        guard let data = jsonString.data(using: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return nil
+        }
+        return encode(json)
+    }
+
+    static func decode(_ json: [String: Any]) -> [String: Any] {
+        if isCameraCommandJson(jsonString(json) ?? "") {
+            return json
+        }
+        return expandObject(json, topLevel: true)
+    }
+
+    static func decodeIfSupported(_ json: [String: Any]) -> [String: Any]? {
+        if isCameraCommandJson(jsonString(json) ?? "") {
+            return json
+        }
+        if !isCompactWireForm(json) {
+            return json
+        }
+        let compactType = stringValue(json["t"]) ?? ""
+        if !supportsCompactInbound(compactType) {
+            return nil
+        }
+        return expandObject(json, topLevel: true)
+    }
+
+    static func decode(jsonString: String) -> [String: Any]? {
+        guard let data = jsonString.data(using: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return nil
+        }
+        return decode(json)
+    }
+
+    /// Compact JSON reserves short keys and enum integers. Fall back to verbose JSON whenever an
+    /// otherwise valid future payload already uses one of those wire representations.
+    private static func canCompactLosslessly(
+        _ input: [String: Any],
+        topLevel: Bool
+    ) -> Bool {
+        let messageType = stringValue(input["type"]) ?? stringValue(input["t"]) ?? ""
+        for (key, value) in input {
+            if shortToLong[key] != nil
+                || (topLevel && key == keyResolvedConfigHash)
+                || isAmbiguousEnumValue(key: key, value: value, messageType: messageType)
+            {
+                return false
+            }
+            if let nested = value as? [String: Any],
+               !canCompactLosslessly(nested, topLevel: false)
+            {
+                return false
+            }
+            if let array = value as? [Any], !canCompactArrayLosslessly(array) {
+                return false
+            }
+        }
+        return true
+    }
+
+    private static func canCompactArrayLosslessly(_ array: [Any]) -> Bool {
+        for value in array {
+            if let nested = value as? [String: Any],
+               !canCompactLosslessly(nested, topLevel: false)
+            {
+                return false
+            }
+            if let nestedArray = value as? [Any],
+               !canCompactArrayLosslessly(nestedArray)
+            {
+                return false
+            }
+        }
+        return true
+    }
+
+    private static func isAmbiguousEnumValue(
+        key: String,
+        value: Any,
+        messageType: String
+    ) -> Bool {
+        guard let number = value as? NSNumber,
+              CFGetTypeID(number) != CFBooleanGetTypeID()
+        else {
+            return false
+        }
+        return key == "kind"
+            || key == "source"
+            || key == "aeStateName"
+            || (key == "status" && messageType == "photo_status")
+    }
+
+    private static func compactObject(_ input: [String: Any], topLevel: Bool) -> [String: Any] {
+        var output: [String: Any] = [:]
+        let messageType = stringValue(input["type"]) ?? stringValue(input["t"]) ?? ""
+
+        for (key, value) in input {
+            if let compacted = compactValue(longKey: key, value: value, messageType: messageType) {
+                // Legacy peers treat top-level `ts` as a session-relative delta. Preserve the
+                // verbose key so an absolute timestamp remains absolute across mixed versions.
+                let wireKey = topLevel && key == "timestamp" ? key : (longToShort[key] ?? key)
+                output[wireKey] = compacted
+            }
+        }
+        return output
+    }
+
+    private static func compactValue(longKey: String, value: Any, messageType: String) -> Any? {
+        if value is NSNull { return NSNull() }
+        if let nested = value as? [String: Any] {
+            return compactObject(nested, topLevel: false)
+        }
+        if let array = value as? [Any] {
+            return array.map { item -> Any in
+                if let nested = item as? [String: Any] {
+                    return compactObject(nested, topLevel: false)
+                }
+                return item
+            }
+        }
+        if let boolValue = value as? Bool { return boolValue }
+        if let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID() {
+            return number
+        }
+        if let str = value as? String {
+            if longKey == "status", messageType == "photo_status", let code = photoStatusToInt[str] {
+                return code
+            }
+            if longKey == "kind", let code = kindToInt[str] { return code }
+            if longKey == "source", let code = sourceToInt[str] { return code }
+            if longKey == "aeStateName", let code = aeStateToInt[str] { return code }
+            return str
+        }
+        return value
+    }
+
+    private static func expandObject(_ input: [String: Any], topLevel: Bool) -> [String: Any] {
+        var output: [String: Any] = [:]
+        let messageType = stringValue(input["type"]) ?? stringValue(input["t"]) ?? ""
+
+        for (key, value) in input {
+            if topLevel, key == "ts" {
+                output["ts"] = value
+                continue
+            }
+            let longKey = shortToLong[key] ?? key
+            if let expanded = expandValue(longKey: longKey, value: value, messageType: messageType) {
+                output[longKey] = expanded
+            }
+        }
+
+        if topLevel {
+            expandTimestamp(&output)
+            expandResolvedConfigHash(&output)
+            cacheResolvedConfigIfPresent(&output)
+        }
+        return output
+    }
+
+    private static func cacheResolvedConfigIfPresent(_ output: inout [String: Any]) {
+        guard let resolvedConfig = output["resolvedConfig"] as? [String: Any] else { return }
+        let hash = hashConfig(resolvedConfig)
+        resolvedConfigByHash[hash] = resolvedConfig
+    }
+
+    private static func expandResolvedConfigHash(_ output: inout [String: Any]) {
+        guard output["resolvedConfig"] == nil,
+              let hash = output[keyResolvedConfigHash] as? String,
+              let cached = resolvedConfigByHash[hash]
+        else {
+            return
+        }
+        output["resolvedConfig"] = cached
+        output.removeValue(forKey: keyResolvedConfigHash)
+    }
+
+    private static func expandValue(longKey: String, value: Any, messageType: String) -> Any? {
+        if value is NSNull { return NSNull() }
+        if let nested = value as? [String: Any] {
+            return expandObject(nested, topLevel: false)
+        }
+        if let array = value as? [Any] {
+            return array.map { item -> Any in
+                if let nested = item as? [String: Any] {
+                    return expandObject(nested, topLevel: false)
+                }
+                return item
+            }
+        }
+        if longKey == "status", messageType == "photo_status", let code = value as? Int {
+            return photoStatusFromInt[code] ?? value
+        }
+        if longKey == "kind", let code = value as? Int {
+            return kindFromInt[code] ?? value
+        }
+        if longKey == "source", let code = value as? Int {
+            return sourceFromInt[code] ?? value
+        }
+        if longKey == "aeStateName", let code = value as? Int {
+            return aeStateFromInt[code] ?? value
+        }
+        return value
+    }
+
+    private static func expandTimestamp(_ output: inout [String: Any]) {
+        guard output["timestamp"] == nil, let timestamp = output["ts"] else { return }
+        guard let delta = int64Value(timestamp) else {
+            output["timestamp"] = timestamp
+            output.removeValue(forKey: "ts")
+            return
+        }
+        let absolute = sessionConnectEpochMs > 0 ? sessionConnectEpochMs + delta : delta
+        output["timestamp"] = absolute
+        output.removeValue(forKey: "ts")
+        if sessionConnectEpochMs <= 0 {
+            sessionConnectEpochMs = absolute - delta
+        }
+    }
+
+    static func hashConfig(_ config: [String: Any]) -> String {
+        fnv1a32Hex(canonicalJsonString(config))
+    }
+
+    private static func canonicalJsonString(_ object: [String: Any]) -> String {
+        let sortedKeys = object.keys.sorted()
+        var parts: [String] = []
+        for key in sortedKeys {
+            guard let value = object[key] else { continue }
+            let encodedValue: String
+            if let nested = value as? [String: Any] {
+                encodedValue = canonicalJsonString(nested)
+            } else if let str = value as? String {
+                encodedValue = "\"\(str)\""
+            } else if let boolValue = value as? Bool {
+                encodedValue = boolValue ? "true" : "false"
+            } else if let number = value as? NSNumber {
+                encodedValue = "\(number)"
+            } else {
+                encodedValue = "null"
+            }
+            parts.append("\"\(key)\":\(encodedValue)")
+        }
+        return "{\(parts.joined(separator: ","))}"
+    }
+
+    private static func fnv1a32Hex(_ value: String) -> String {
+        var hash: UInt32 = 0x811c9dc5
+        for byte in value.utf8 {
+            hash ^= UInt32(byte)
+            hash = hash &* 0x01000193
+        }
+        return String(format: "%08x", hash)
+    }
+
+    private static func stringValue(_ value: Any?) -> String? {
+        if let str = value as? String { return str }
+        if let number = value as? NSNumber { return number.stringValue }
+        return nil
+    }
+
+    private static func int64Value(_ value: Any?) -> Int64? {
+        if let number = value as? NSNumber { return number.int64Value }
+        if let str = value as? String, let parsed = Int64(str) { return parsed }
+        return nil
+    }
+
+    private static func jsonString(_ json: [String: Any]) -> String? {
+        guard let data = try? JSONSerialization.data(withJSONObject: json) else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+}

package/ios/Source/utils/BleWireProtocol.swift

@@ -0,0 +1,92 @@
+import Foundation
+
+/// BLE Wire Protocol v2 shared constants and binary frame helpers.
+/// All multi-byte fields use little-endian byte order.
+enum BleWireProtocol {
+    static let cmdTypeBinaryMsg: UInt8 = 0x40
+
+    static let flagFirstFrag: UInt8 = 0x01
+    static let flagLastFrag: UInt8 = 0x02
+    static let flagWake: UInt8 = 0x04
+    static let flagHandshake: UInt8 = 0x08
+    static let flagAckRequested: UInt8 = 0x10
+
+    static let binaryHeaderSize = 7
+    static let maxFragmentPayload = 480
+    static let mtuTarget = 509
+
+    static let handshakePayloadV2 = "v2"
+    static let protocolV1 = 1
+    static let protocolV2 = 2
+
+    struct BinaryFragmentInfo {
+        let flags: UInt8
+        let msgId: UInt16
+        let fragIdx: UInt8
+        let fragCount: UInt8
+        let payload: Data
+    }
+
+    static func isBinaryFrame(_ data: Data) -> Bool {
+        guard data.count >= 7 else { return false }
+        let bytes = [UInt8](data)
+        return bytes[0] == 0x23 && bytes[1] == 0x23 && bytes[2] == cmdTypeBinaryMsg
+    }
+
+    static func packBinaryFragment(
+        flags: UInt8,
+        msgId: UInt16,
+        fragIdx: UInt8,
+        fragCount: UInt8,
+        payload: Data
+    ) -> Data? {
+        var inner = Data(capacity: binaryHeaderSize + payload.count)
+        inner.append(flags)
+        inner.append(UInt8(msgId & 0xFF))
+        inner.append(UInt8((msgId >> 8) & 0xFF))
+        inner.append(fragIdx)
+        inner.append(fragCount)
+        let payloadLen = UInt16(payload.count)
+        inner.append(UInt8(payloadLen & 0xFF))
+        inner.append(UInt8((payloadLen >> 8) & 0xFF))
+        inner.append(payload)
+        return packDataToK900(inner, cmdType: cmdTypeBinaryMsg)
+    }
+
+    static func extractBinaryFragmentInfo(_ frame: Data) -> BinaryFragmentInfo? {
+        guard isBinaryFrame(frame) else { return nil }
+        let bytes = [UInt8](frame)
+        let innerLen = Int(bytes[3]) | (Int(bytes[4]) << 8)
+        guard innerLen >= binaryHeaderSize, frame.count >= 7 + innerLen else { return nil }
+
+        let offset = 5
+        let payloadLen = Int(bytes[offset + 5]) | (Int(bytes[offset + 6]) << 8)
+        guard binaryHeaderSize + payloadLen <= innerLen else { return nil }
+
+        let payload = frame.subdata(in: (offset + binaryHeaderSize) ..< (offset + binaryHeaderSize + payloadLen))
+        return BinaryFragmentInfo(
+            flags: bytes[offset],
+            msgId: UInt16(bytes[offset + 1]) | (UInt16(bytes[offset + 2]) << 8),
+            fragIdx: bytes[offset + 3],
+            fragCount: bytes[offset + 4],
+            payload: payload
+        )
+    }
+
+    static func isHandshakeV2(_ info: BinaryFragmentInfo) -> Bool {
+        guard (info.flags & flagHandshake) != 0 else { return false }
+        return String(data: info.payload, encoding: .utf8) == handshakePayloadV2
+    }
+
+    private static func packDataToK900(_ data: Data, cmdType: UInt8) -> Data? {
+        var result = Data(capacity: data.count + 7)
+        result.append(contentsOf: [0x23, 0x23])
+        result.append(cmdType)
+        let dataLength = UInt16(data.count)
+        result.append(UInt8(dataLength & 0xFF))
+        result.append(UInt8((dataLength >> 8) & 0xFF))
+        result.append(data)
+        result.append(contentsOf: [0x24, 0x24])
+        return result
+    }
+}

package/ios/Source/utils/Constants.swift

@@ -0,0 +1,78 @@
+struct DeviceTypes {
+    static let SIMULATED = "Simulated Glasses"
+    static let G1 = "Even Realities G1"
+    static let G2 = "Even Realities G2"
+    static let LIVE = "Mentra Live"
+    static let MACH1 = "Mentra Mach1"
+    static let Z100 = "Vuzix Z100"
+    static let NEX = "Mentra Display"
+    static let FRAME = "Brilliant Frame"
+    static let NIMO = "NIMO"
+    static let AR99 = "AR99"
+
+    static let ALL = [
+        SIMULATED,
+        G1,
+        G2,
+        MACH1,
+        LIVE,
+        Z100,
+        NEX,
+        FRAME,
+        NIMO,
+        AR99,
+    ]
+
+    /// Private init to prevent instantiation
+    private init() {}
+}
+
+struct ControllerTypes {
+    static let R1 = "Even Realities R1"
+
+    static let ALL = [
+        R1,
+    ]
+
+    /// Private init to prevent instantiation
+    private init() {}
+}
+
+struct ConnTypes {
+    static let CONNECTING = "CONNECTING"
+    static let CONNECTED = "CONNECTED"
+    static let DISCONNECTED = "DISCONNECTED"
+    static let SCANNING = "SCANNING"
+    static let BONDING = "BONDING"
+
+    /// Private init to prevent instantiation
+    private init() {}
+}
+
+struct MicTypes {
+    static let PHONE_INTERNAL = "phone"
+    static let GLASSES_CUSTOM = "glasses"
+    static let BLUETOOTH_CLASSIC = "bluetoothClassic"
+    static let BLUETOOTH = "bluetooth"
+
+    static let ALL = [
+        PHONE_INTERNAL,
+        GLASSES_CUSTOM,
+        BLUETOOTH_CLASSIC,
+        BLUETOOTH,
+    ]
+
+    /// Private init to prevent instantiation
+    private init() {}
+}
+
+enum MicMap {
+    static var map: [String: [String]] = [
+        "auto": [
+            MicTypes.GLASSES_CUSTOM, MicTypes.PHONE_INTERNAL, MicTypes.BLUETOOTH, MicTypes.BLUETOOTH_CLASSIC,
+        ],
+        "glasses": [MicTypes.GLASSES_CUSTOM],
+        "phone": [MicTypes.PHONE_INTERNAL, MicTypes.GLASSES_CUSTOM],
+        "bluetooth": [MicTypes.BLUETOOTH, MicTypes.BLUETOOTH_CLASSIC, MicTypes.PHONE_INTERNAL, MicTypes.GLASSES_CUSTOM],
+    ]
+}

package/ios/Source/utils/Enums.swift

@@ -0,0 +1,95 @@
+//
+//  Enums.swift
+//  Glassly_Manager
+//
+//  Created by Matthew Fosse on 3/3/25.
+//
+
+import Foundation
+
+enum CommandResponse: UInt8 {
+    case ACK = 0xC9
+    case CONTINUE = 0xCB
+}
+
+enum Commands: UInt8 {
+    case BLE_EXIT_ALL_FUNCTIONS = 0x18
+    case BLE_REQ_INIT = 0x4D
+    case BLE_REQ_BATTERY = 0x2C
+    case BLE_REQ_HEARTBEAT = 0x25
+    case BLE_REQ_EVENAI = 0x4E
+    case BLE_REQ_TRANSFER_MIC_DATA = 0xF1
+    case BLE_REQ_DEVICE_ORDER = 0xF5
+    case BLE_REQ_MIC_ON = 0x0E
+    case QUICK_NOTE_ADD = 0x1E
+    case CRC_CHECK = 0x16
+    case BMP_END = 0x20
+    case BRIGHTNESS = 0x01
+    case WHITELIST = 0x04
+    case SILENT_MODE = 0x03
+    case DASHBOARD_LAYOUT_COMMAND = 0x26
+    case DASHBOARD_SHOW = 0x06
+    case HEAD_UP_ANGLE = 0x0B
+    case UNK_2 = 0x39
+    case UNK_1 = 0x50
+}
+
+enum DeviceOrders: UInt8 {
+    case DISPLAY_READY = 0x00
+    case TRIGGER_CHANGE_PAGE = 0x01
+    case TRIGGER_FOR_AI = 0x17
+    case TRIGGER_FOR_STOP_RECORDING = 0x18
+    case G1_IS_READY = 0x09
+    case HEAD_UP = 0x1E
+    case HEAD_DOWN = 0x1F
+    case SILENCED = 0x04
+    case ACTIVATED = 0x05
+    case HEAD_UP2 = 0x02
+    case HEAD_DOWN2 = 0x03
+    case CASE_REMOVED = 0x07
+    case CASE_REMOVED2 = 0x06
+    case CASE_OPEN = 0x08
+    case CASE_CLOSED = 0x0B
+    case CASE_CHARGING_STATUS = 0x0E
+    case CASE_CHARGE_INFO = 0x0F
+    case DOUBLE_TAP = 0x20
+}
+
+enum DisplayStatus: UInt8 {
+    case NORMAL_TEXT = 0x30
+    case FINAL_TEXT = 0x40
+    case MANUAL_PAGE = 0x50
+    case ERROR_TEXT = 0x60
+    case SIMPLE_TEXT = 0x70
+}
+
+public enum DashboardHeight: UInt8 {
+    case position0 = 0x00 // Bottom
+    case position1 = 0x01
+    case position2 = 0x02
+    case position3 = 0x03
+    case position4 = 0x04
+    case position5 = 0x05
+    case position6 = 0x06
+    case position7 = 0x07
+    case position8 = 0x08 // Top
+}
+
+public enum DashboardDepth: UInt8 {
+    case position0 = 0x00 // Bottom
+    case position1 = 0x01
+    case position2 = 0x02
+    case position3 = 0x03
+    case position4 = 0x04
+    case position5 = 0x05
+    case position6 = 0x06
+    case position7 = 0x07
+    case position8 = 0x08
+    case position9 = 0x09
+}
+
+public enum DashboardMode: UInt8 {
+    case full = 0x00
+    case dual = 0x01
+    case minimal = 0x02
+}