@glassly/bluetooth-sdk 0.1.0-dev.26

package/ios/Source/OtaManifest.swift

@@ -0,0 +1,211 @@
+import Foundation
+
+enum OtaManifestDefaults {
+    // ASG builds before 39 ignore ota_start.ota_version_url, so SDK checks must
+    // use the same legacy production manifest those glasses will install from.
+    static let legacyProdOtaVersionUrl = "https://ota.glassly.ai/prod_live_version.json"
+
+    static func defaultOtaVersionUrl() throws -> String {
+        let manifestUrl = GeneratedReleaseMetadata.otaManifestUrl.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !manifestUrl.isEmpty else {
+            throw BluetoothSdkError(
+                code: "ota_manifest_unconfigured",
+                message: "This source-built Bluetooth SDK has no embedded OTA manifest. Configure one with the debug API."
+            )
+        }
+        return manifestUrl
+    }
+}
+
+struct OtaManifestApp: Decodable {
+    let versionCode: Int?
+}
+
+struct MtkPatch: Decodable {
+    let startFirmware: String
+
+    enum CodingKeys: String, CodingKey {
+        case startFirmware = "start_firmware"
+    }
+}
+
+struct BesFirmware: Decodable {
+    let version: String?
+}
+
+struct OtaManifest: Decodable {
+    let apps: [String: OtaManifestApp]?
+    let mtkPatches: [MtkPatch]?
+    let besFirmware: BesFirmware?
+    let versionCode: Int?
+
+    enum CodingKeys: String, CodingKey {
+        case apps
+        case mtkPatches = "mtk_patches"
+        case besFirmware = "bes_firmware"
+        case versionCode
+    }
+}
+
+enum OtaManifestChecker {
+    private static let asgClientPackage = "com.mentra.asg_client"
+
+    static func normalizeHttpUrl(_ value: String) throws -> String {
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            throw BluetoothSdkError(code: "invalid_ota_url", message: "OTA version URL must be a non-empty http(s) URL.")
+        }
+        guard let url = URL(string: trimmed),
+              let scheme = url.scheme?.lowercased(),
+              (scheme == "http" || scheme == "https"),
+              url.host?.isEmpty == false
+        else {
+            throw BluetoothSdkError(code: "invalid_ota_url", message: "OTA version URL must be a valid http(s) URL.")
+        }
+        return url.absoluteString
+    }
+
+    static func fetch(_ otaVersionUrl: String) async throws -> OtaManifest {
+        guard let url = URL(string: otaVersionUrl) else {
+            throw BluetoothSdkError(code: "invalid_ota_url", message: "OTA version URL must be a valid http(s) URL.")
+        }
+        let (data, response) = try await URLSession.shared.data(from: url)
+        guard let httpResponse = response as? HTTPURLResponse else {
+            throw BluetoothSdkError(code: "ota_manifest_request_failed", message: "OTA manifest request failed.")
+        }
+        guard (200 ... 299).contains(httpResponse.statusCode) else {
+            throw BluetoothSdkError(
+                code: "ota_manifest_request_failed",
+                message: "OTA manifest request failed with HTTP \(httpResponse.statusCode) for \(otaVersionUrl)."
+            )
+        }
+        return try JSONDecoder().decode(OtaManifest.self, from: data)
+    }
+
+    static func hasUpdate(
+        currentBuildNumber: String,
+        currentMtkVersion: String,
+        currentBesVersion: String,
+        manifest: OtaManifest,
+        // Downgrade floor: a non-positive value (the default) disables downgrades entirely,
+        // matching ASG's fail-closed DowngradeGate and the engine. OEM SDK consumers that do not
+        // set a floor get upgrade-only behavior and are never told a downgrade is available that
+        // the glasses would refuse.
+        downgradeFloorVersionCode: Int = 0
+    ) throws -> Bool {
+        try hasApkUpdate(
+            currentBuildNumber: currentBuildNumber,
+            manifest: manifest,
+            downgradeFloorVersionCode: downgradeFloorVersionCode
+        ) ||
+            hasMtkUpdate(patches: manifest.mtkPatches, currentVersion: currentMtkVersion) ||
+            hasBesUpdate(besFirmware: manifest.besFirmware, currentVersion: currentBesVersion)
+    }
+
+    static func hasMtkPatches(_ manifest: OtaManifest) -> Bool {
+        !(manifest.mtkPatches?.isEmpty ?? true)
+    }
+
+    static func hasBesFirmware(_ manifest: OtaManifest) -> Bool {
+        manifest.besFirmware != nil
+    }
+
+    private static func latestAppInfo(_ manifest: OtaManifest) throws -> OtaManifestApp {
+        if let app = manifest.apps?[asgClientPackage], app.versionCode != nil {
+            return app
+        }
+        if let versionCode = manifest.versionCode {
+            return OtaManifestApp(versionCode: versionCode)
+        }
+        throw BluetoothSdkError(code: "invalid_ota_manifest", message: "OTA manifest is missing ASG app versionCode.")
+    }
+
+    private static func hasApkUpdate(
+        currentBuildNumber: String,
+        manifest: OtaManifest,
+        downgradeFloorVersionCode: Int
+    ) throws -> Bool {
+        guard let currentVersion = Int(currentBuildNumber) else {
+            throw BluetoothSdkError(
+                code: "invalid_glasses_version",
+                message: "Cannot check OTA update because glasses build number is invalid."
+            )
+        }
+        guard let serverVersion = try latestAppInfo(manifest).versionCode else {
+            throw BluetoothSdkError(code: "invalid_ota_manifest", message: "OTA manifest is missing ASG app versionCode.")
+        }
+        // Only apps-shaped manifests are exact pins. A legacy top-level manifest (versionCode at
+        // the root, no apps entry) is NOT a pin and stays strictly upgrade-only, matching the
+        // engine TS checker and Kotlin.
+        let isExactPin = manifest.apps?[asgClientPackage]?.versionCode != nil
+        if !isExactPin {
+            return serverVersion > currentVersion
+        }
+        // Exact pin: any mismatch is an update in either direction (downgrades take the
+        // uninstall-then-reinstall detour on the glasses). A non-positive pin is only legitimate
+        // in the frozen legacy rescue manifests that pre-39 glasses are checked against; for
+        // modern glasses it means the manifest cannot verify anything, and that must surface as
+        // an error — never as "no update". Mirrors the Kotlin OtaManifestChecker.
+        if serverVersion <= 0 {
+            if currentVersion >= 39 {
+                throw BluetoothSdkError(
+                    code: "invalid_ota_manifest",
+                    message: "OTA manifest ASG pin is missing or zero; cannot verify update state."
+                )
+            }
+            return false
+        }
+        if serverVersion > currentVersion {
+            return true
+        }
+        // Exact match: already on the pin, no update.
+        if serverVersion == currentVersion {
+            return false
+        }
+        // Downgrade: only actionable at/above the enabled floor; a non-positive floor disables
+        // downgrades (fail closed, matching ASG and the engine).
+        return downgradeFloorVersionCode > 0 && serverVersion >= downgradeFloorVersionCode
+    }
+
+    private static func hasMtkUpdate(patches: [MtkPatch]?, currentVersion: String) throws -> Bool {
+        guard let patches, !patches.isEmpty else { return false }
+        guard !currentVersion.isEmpty else { return false }
+
+        return patches.contains { patch in
+            if patch.startFirmware == currentVersion {
+                return true
+            }
+            let serverDate = patch.startFirmware.contains("_")
+                ? String(patch.startFirmware.split(separator: "_").last ?? "")
+                : patch.startFirmware
+            return serverDate == currentVersion
+        }
+    }
+
+    private static func hasBesUpdate(besFirmware: BesFirmware?, currentVersion: String) throws -> Bool {
+        guard let besFirmware else { return false }
+        guard let serverVersion = besFirmware.version, !serverVersion.isEmpty else {
+            throw BluetoothSdkError(code: "invalid_ota_manifest", message: "OTA manifest bes_firmware.version is missing.")
+        }
+        if currentVersion.isEmpty {
+            return true
+        }
+        return compareVersions(serverVersion, currentVersion) > 0
+    }
+
+    private static func compareVersions(_ version1: String, _ version2: String) -> Int {
+        if version1.contains("."), version2.contains(".") {
+            let parts1 = version1.split(separator: ".").map { Int($0) ?? 0 }
+            let parts2 = version2.split(separator: ".").map { Int($0) ?? 0 }
+            for index in 0 ..< max(parts1.count, parts2.count) {
+                let value1 = index < parts1.count ? parts1[index] : 0
+                let value2 = index < parts2.count ? parts2[index] : 0
+                if value1 != value2 {
+                    return value1 - value2
+                }
+            }
+            return 0
+        }
+        return version1.compare(version2).rawValue
+    }
+}

package/ios/Source/PrivacyInfo.xcprivacy

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>NSPrivacyTracking</key>
+  <false/>
+  <key>NSPrivacyCollectedDataTypes</key>
+  <array/>
+  <key>NSPrivacyTrackingDomains</key>
+  <array/>
+  <key>NSPrivacyAccessedAPITypes</key>
+  <array>
+    <dict>
+      <key>NSPrivacyAccessedAPIType</key>
+      <string>NSPrivacyAccessedAPICategoryUserDefaults</string>
+      <key>NSPrivacyAccessedAPITypeReasons</key>
+      <array>
+        <string>CA92.1</string>
+      </array>
+    </dict>
+  </array>
+</dict>
+</plist>

package/ios/Source/ReleaseChangelog.swift

@@ -0,0 +1,65 @@
+import Foundation
+
+/// One coordinated Glassly release note authored in /changelogs/<version>.md.
+public struct ReleaseChangelog: Equatable, Sendable {
+    public let version: String
+    public let markdown: String
+
+    public init(version: String, markdown: String) {
+        self.version = version
+        self.markdown = markdown
+    }
+}
+
+enum ReleaseChangelogCatalog {
+    static func select(fromVersion: String?, toVersion: String?) throws -> [ReleaseChangelog] {
+        let fallbackTarget = GeneratedReleaseMetadata.familyBaseVersion.isEmpty
+            ? (generatedReleaseChangelogs.first?.version ?? "")
+            : GeneratedReleaseMetadata.familyBaseVersion
+        if fallbackTarget.isEmpty, toVersion == nil { return [] }
+        let target = try baseVersion(toVersion ?? fallbackTarget, label: "toVersion")
+        guard generatedReleaseChangelogs.contains(where: { $0.version == target }) else {
+            throw BluetoothSdkError(code: "missing_changelog", message: "No changelog is bundled for target version \(target).")
+        }
+        guard let fromVersion else {
+            return generatedReleaseChangelogs.filter { $0.version == target }
+        }
+
+        let source = try baseVersion(fromVersion, label: "fromVersion")
+        let direction = compareVersions(target, source)
+        return generatedReleaseChangelogs.filter { entry in
+            if direction == 0 { return entry.version == target }
+            if direction > 0 {
+                return compareVersions(entry.version, source) > 0 && compareVersions(entry.version, target) <= 0
+            }
+            return compareVersions(entry.version, source) < 0 && compareVersions(entry.version, target) >= 0
+        }
+    }
+
+    private static func baseVersion(_ version: String, label: String) throws -> String {
+        let value = version.trimmingCharacters(in: .whitespacesAndNewlines)
+        let suffixStart = value.firstIndex(where: { $0 == "-" || $0 == "+" }) ?? value.endIndex
+        let components = value[..<suffixStart].split(separator: ".", omittingEmptySubsequences: false)
+        let isValid = components.count == 3 && components.allSatisfy { component in
+            !component.isEmpty
+                && (component == "0" || !component.hasPrefix("0"))
+                && component.utf8.allSatisfy { byte in byte >= 48 && byte <= 57 }
+        }
+        guard isValid else {
+            throw BluetoothSdkError(
+                code: "invalid_changelog_version",
+                message: "\(label) must be a semantic version such as 3.1.0, 3.1.0-dev.4, or 3.1.0-beta.2."
+            )
+        }
+        return components.joined(separator: ".")
+    }
+
+    private static func compareVersions(_ left: String, _ right: String) -> Int {
+        let a = left.split(separator: ".").map { Int($0) ?? 0 }
+        let b = right.split(separator: ".").map { Int($0) ?? 0 }
+        for index in 0 ..< 3 where a[index] != b[index] {
+            return a[index] - b[index]
+        }
+        return 0
+    }
+}

package/ios/Source/Resources/G2Firmware/README.md

@@ -0,0 +1,10 @@
+# Bundled G2 firmware
+
+The iOS target bundles the stock and Glassly CFW EVENOTA images stored in this
+directory. They were copied from the sibling `g2flash` checkout:
+
+- `g2_2.2.6.10.bin` -> `g2-stock-2.2.6.10.evenota.bin`
+- `g2_2.2.6.10_cfw.bin` -> `g2-glassly-cfw-2.2.6.10.evenota.bin`
+
+Run `./build_cfw.sh` in `g2flash` before manually replacing the CFW image. The
+firmware binaries are intentionally ignored by Git.

package/ios/Source/audio/AudioModels.swift

@@ -0,0 +1,178 @@
+import Foundation
+
+public enum MicPreference: String {
+    case auto
+    case phone
+    case glasses
+    case bluetooth
+}
+
+struct MicHealth {
+    let sequenceGapEvents: Int64
+    let decodeFailures: Int64
+    let lastLc3ReceivedAt: Int64?
+    let lastPcmProducedAt: Int64?
+
+    var dictionary: [String: Any] {
+        var values: [String: Any] = [
+            "sequenceGapEvents": sequenceGapEvents,
+            "decodeFailures": decodeFailures,
+        ]
+        if let lastLc3ReceivedAt { values["lastLc3ReceivedAt"] = lastLc3ReceivedAt }
+        if let lastPcmProducedAt { values["lastPcmProducedAt"] = lastPcmProducedAt }
+        return values
+    }
+}
+
+public struct LocalTranscriptionEvent: CustomStringConvertible {
+    public let text: String
+    public let isFinal: Bool
+    public let values: [String: Any]
+
+    public init(text: String, isFinal: Bool, values: [String: Any]) {
+        self.text = text
+        self.isFinal = isFinal
+        self.values = values
+    }
+
+    public var description: String {
+        "LocalTranscriptionEvent(text: \(text), isFinal: \(isFinal))"
+    }
+}
+
+public struct MicPcmEvent: CustomStringConvertible {
+    public static let sampleRate = 16000
+    public static let bitsPerSample = 16
+    public static let channels = 1
+    public static let encoding = "pcm_s16le"
+
+    public let pcm: Data
+    public let sampleRate: Int
+    public let bitsPerSample: Int
+    public let channels: Int
+    public let encoding: String
+    public let voiceActivityDetectionEnabled: Bool
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        let pcm = values["pcm"] as? Data ?? Data()
+        let sampleRate = intValue(values["sampleRate"]) ?? Self.sampleRate
+        let bitsPerSample = intValue(values["bitsPerSample"]) ?? Self.bitsPerSample
+        let channels = intValue(values["channels"]) ?? Self.channels
+        let encoding = values["encoding"] as? String ?? Self.encoding
+        let voiceActivityDetectionEnabled =
+            boolValue(values, "voiceActivityDetectionEnabled") ?? BluetoothSdkDefaults.voiceActivityDetectionEnabled
+
+        var normalized = values
+        normalized["type"] = "mic_pcm"
+        normalized["pcm"] = pcm
+        normalized["sampleRate"] = sampleRate
+        normalized["bitsPerSample"] = bitsPerSample
+        normalized["channels"] = channels
+        normalized["encoding"] = encoding
+        normalized["voiceActivityDetectionEnabled"] = voiceActivityDetectionEnabled
+
+        self.pcm = pcm
+        self.sampleRate = sampleRate
+        self.bitsPerSample = bitsPerSample
+        self.channels = channels
+        self.encoding = encoding
+        self.voiceActivityDetectionEnabled = voiceActivityDetectionEnabled
+        self.values = normalized
+    }
+
+    public var description: String {
+        "MicPcmEvent(bytes: \(pcm.count), sampleRate: \(sampleRate), bitsPerSample: \(bitsPerSample), channels: \(channels), encoding: \(encoding), voiceActivityDetectionEnabled: \(voiceActivityDetectionEnabled))"
+    }
+}
+
+public struct MicLc3Event: CustomStringConvertible {
+    public static let sampleRate = 16000
+    public static let channels = 1
+    public static let encoding = "lc3"
+    public static let frameDurationMs = 10
+    public static let defaultFrameSizeBytes = 60
+
+    public let lc3: Data
+    public let sampleRate: Int
+    public let channels: Int
+    public let encoding: String
+    public let frameDurationMs: Int
+    public let frameSizeBytes: Int
+    public let bitrate: Int
+    public let packetizedFromGlasses: Bool
+    public let voiceActivityDetectionEnabled: Bool
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        let lc3 = values["lc3"] as? Data ?? Data()
+        let sampleRate = intValue(values["sampleRate"]) ?? Self.sampleRate
+        let channels = intValue(values["channels"]) ?? Self.channels
+        let encoding = values["encoding"] as? String ?? Self.encoding
+        let frameDurationMs = intValue(values["frameDurationMs"]) ?? Self.frameDurationMs
+        let frameSizeBytes = intValue(values["frameSizeBytes"]) ?? Self.defaultFrameSizeBytes
+        let bitrate = intValue(values["bitrate"]) ?? frameSizeBytes * 8 * (1000 / frameDurationMs)
+        let packetizedFromGlasses = boolValue(values, "packetizedFromGlasses") ?? false
+        let voiceActivityDetectionEnabled =
+            boolValue(values, "voiceActivityDetectionEnabled") ?? BluetoothSdkDefaults.voiceActivityDetectionEnabled
+
+        var normalized = values
+        normalized["type"] = "mic_lc3"
+        normalized["lc3"] = lc3
+        normalized["sampleRate"] = sampleRate
+        normalized["channels"] = channels
+        normalized["encoding"] = encoding
+        normalized["frameDurationMs"] = frameDurationMs
+        normalized["frameSizeBytes"] = frameSizeBytes
+        normalized["bitrate"] = bitrate
+        normalized["packetizedFromGlasses"] = packetizedFromGlasses
+        normalized["voiceActivityDetectionEnabled"] = voiceActivityDetectionEnabled
+
+        self.lc3 = lc3
+        self.sampleRate = sampleRate
+        self.channels = channels
+        self.encoding = encoding
+        self.frameDurationMs = frameDurationMs
+        self.frameSizeBytes = frameSizeBytes
+        self.bitrate = bitrate
+        self.packetizedFromGlasses = packetizedFromGlasses
+        self.voiceActivityDetectionEnabled = voiceActivityDetectionEnabled
+        self.values = normalized
+    }
+
+    public var description: String {
+        "MicLc3Event(bytes: \(lc3.count), sampleRate: \(sampleRate), channels: \(channels), frameDurationMs: \(frameDurationMs), frameSizeBytes: \(frameSizeBytes), bitrate: \(bitrate), packetizedFromGlasses: \(packetizedFromGlasses), voiceActivityDetectionEnabled: \(voiceActivityDetectionEnabled))"
+    }
+}
+
+public struct GlassesMediaVolumeGetResult: CustomStringConvertible {
+    public let level: Int?
+    public let statusCode: Int?
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        level = intValue(values["level"])
+        statusCode = intValue(values["statusCode"])
+        self.values = values
+    }
+
+    public var description: String {
+        let levelText = level.map(String.init) ?? "unknown"
+        let statusCodeText = statusCode.map(String.init) ?? "unknown"
+        return "GlassesMediaVolumeGetResult(level: \(levelText), statusCode: \(statusCodeText))"
+    }
+}
+
+public struct GlassesMediaVolumeSetResult: CustomStringConvertible {
+    public let statusCode: Int?
+    public let values: [String: Any]
+
+    public init(values: [String: Any]) {
+        statusCode = intValue(values["statusCode"])
+        self.values = values
+    }
+
+    public var description: String {
+        "GlassesMediaVolumeSetResult(statusCode: \(statusCode.map(String.init) ?? "unknown"))"
+    }
+}