@mentra/bluetooth-sdk 0.1.12 → 0.1.13

package/ios/Source/BluetoothSdkDefaults.swift

@@ -3,10 +3,16 @@ import Foundation
 /// Defaults for the public Bluetooth SDK surface.
 enum BluetoothSdkDefaults {
     static var sdkVersion: String? {
-        packageVersion(from: sdkBundle)
+        #if SWIFT_PACKAGE
+            normalizedSdkVersion(swiftPackageSdkVersion)
+        #else
+            packageVersion(from: sdkBundle)
+        #endif
     }
 
     static let voiceActivityDetectionEnabled = false
+    private static let swiftPackageSdkVersion = "__MENTRA_BLUETOOTH_SDK_VERSION__"
+    private static let swiftPackageSdkVersionPlaceholder = "__MENTRA" + "_BLUETOOTH_SDK_VERSION__"
 
     private static var sdkBundle: Bundle {
         #if SWIFT_PACKAGE
@@ -21,13 +27,27 @@ enum BluetoothSdkDefaults {
         let build = bundle.object(forInfoDictionaryKey: "CFBundleVersion") as? String
 
         for candidate in [version, build] {
-            if let candidate, !candidate.isEmpty, candidate != "1.0" {
-                return candidate
+            if let sdkVersion = normalizedSdkVersion(candidate) {
+                return sdkVersion
             }
         }
 
         return nil
     }
+
+    private static func normalizedSdkVersion(_ value: String?) -> String? {
+        guard let value else {
+            return nil
+        }
+        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty,
+              trimmed != "1.0",
+              trimmed != swiftPackageSdkVersionPlaceholder
+        else {
+            return nil
+        }
+        return trimmed
+    }
 }
 
 private final class BluetoothSdkBundleToken {}

package/ios/Source/DeviceManager.swift

@@ -1169,9 +1169,9 @@ struct ViewState {
     /// Send OTA start command to glasses.
     /// Called when user approves an update (onboarding or background mode).
     /// Triggers glasses to begin download and installation.
-    func sendOtaStart() {
+    func sendOtaStart(otaVersionUrl: String? = nil) {
         Bridge.log("MAN: 📱 Sending OTA start command to glasses")
-        sgc?.sendOtaStart()
+        sgc?.sendOtaStart(otaVersionUrl: otaVersionUrl)
     }
 
     func sendOtaQueryStatus() {
@@ -1191,7 +1191,14 @@ struct ViewState {
     }
 
     func sendButtonPhotoSettings(requestId: String, size: String) throws {
-        try liveSgc().sendButtonPhotoSettings(requestId: requestId, size: size)
+        try sendButtonPhotoSettings(
+            requestId: requestId,
+            settings: ButtonPhotoSettings(size: ButtonPhotoSize(normalizedRawValue: size))
+        )
+    }
+
+    func sendButtonPhotoSettings(requestId: String, settings: ButtonPhotoSettings) throws {
+        try liveSgc().sendButtonPhotoSettings(requestId: requestId, settings: settings)
     }
 
     func sendButtonVideoRecordingSettings(requestId: String, width: Int, height: Int, fps: Int) throws {
@@ -1317,36 +1324,40 @@ struct ViewState {
         }
     }
 
-    func requestPhoto(
-        _ requestId: String,
-        _ appId: String,
-        _ size: String,
-        _ webhookUrl: String?,
-        _ authToken: String?,
-        _ compress: String?,
-        _ flash: Bool,
-        _ save: Bool,
-        _ sound: Bool,
-        exposureTimeNs: Double? = nil,
-        iso: Int? = nil
-    ) {
-        // Only honor manual exposure when it is a usable value; manual ISO is a one-shot
-        // companion to manual exposure and must be dropped when exposure is invalid.
-        let manualExposureNs = exposureTimeNs.flatMap { $0.isFinite && $0 > 0 ? $0 : nil }
-        let manualIso = manualExposureNs != nil ? iso.flatMap { $0 > 0 ? $0 : nil } : nil
+    func requestPhoto(_ request: PhotoRequest) {
+        let manualExposureNs = request.exposureTimeNs.flatMap { $0.isFinite && $0 > 0 ? $0 : nil }
+        let manualIso = manualExposureNs != nil ? request.iso.flatMap { $0 > 0 ? $0 : nil } : nil
+        let routed = PhotoRequest(
+            requestId: request.requestId,
+            appId: request.appId,
+            size: request.size,
+            webhookUrl: request.webhookUrl,
+            authToken: request.authToken,
+            compress: request.compress,
+            flash: request.flash,
+            save: request.save,
+            sound: request.sound,
+            exposureTimeNs: manualExposureNs,
+            iso: manualIso,
+            aeExposureDivisor: request.aeExposureDivisor,
+            isoCap: request.isoCap,
+            noiseReduction: request.noiseReduction,
+            edgeEnhancement: request.edgeEnhancement,
+            mfnr: request.mfnr,
+            zsl: request.zsl,
+            ispDigitalGain: request.ispDigitalGain,
+            ispAnalogGain: request.ispAnalogGain
+        )
         Bridge.log(
-            "MAN: PHOTO PIPELINE [4/6] DeviceManager.requestPhoto requestId=\(requestId) appId=\(appId) webhookUrl=\(webhookUrl ?? "nil") size=\(size) compress=\(compress ?? "none") flash=\(flash) save=\(save) sound=\(sound) exposureTimeNs=\(manualExposureNs.map { String($0) } ?? "nil") iso=\(manualIso.map { String($0) } ?? "auto") sgc=\(sgc != nil ? String(describing: type(of: sgc!)) : "null")"
+            "MAN: PHOTO PIPELINE [4/6] DeviceManager.requestPhoto requestId=\(routed.requestId) appId=\(routed.appId) webhookUrl=\(routed.webhookUrl ?? "nil") size=\(routed.size.rawValue) compress=\(routed.compress?.rawValue ?? "none") flash=\(routed.flash) save=\(routed.save) sound=\(routed.sound) exposureTimeNs=\(manualExposureNs.map { String($0) } ?? "nil") iso=\(manualIso.map { String($0) } ?? "auto") aeDivisor=\(routed.aeExposureDivisor.map { String($0) } ?? "nil") isoCap=\(routed.isoCap.map { String($0) } ?? "nil") sgc=\(sgc != nil ? String(describing: type(of: sgc!)) : "null")"
         )
         guard let sgc else {
             Bridge.log(
-                "MAN: PHOTO PIPELINE — sgc is null (glasses not connected); dropping requestId=\(requestId)"
+                "MAN: PHOTO PIPELINE — sgc is null (glasses not connected); dropping requestId=\(routed.requestId)"
             )
             return
         }
-        sgc.requestPhoto(
-            requestId, appId: appId, size: size, webhookUrl: webhookUrl, authToken: authToken,
-            compress: compress, flash: flash, save: save, sound: sound, exposureTimeNs: manualExposureNs, iso: manualIso
-        )
+        sgc.requestPhoto(routed)
     }
 
     func connectDefault() {

package/ios/Source/DeviceStore.swift

@@ -91,7 +91,7 @@ class DeviceStore {
         // Mentra Nex feature flag (off by default; toggled from Nex Developer Settings):
         store.set("bluetooth", "nex_chinese_captions", false)
         store.set("bluetooth", "screen_disabled", false)
-        store.set("bluetooth", "button_photo_size", "medium")
+        store.set("bluetooth", "button_photo_size", "max")
         store.set("bluetooth", "button_camera_led", true)
         store.set("bluetooth", "button_max_recording_time", 10)
         store.set("bluetooth", "camera_fov", ["fov": 118, "roi_position": 0])
@@ -116,6 +116,10 @@ class DeviceStore {
         store.set(category, key, value)
     }
 
+    func remove(_ category: String, _ key: String) {
+        store.remove(category, key)
+    }
+
     private func scheduleDashboardHeightToGlasses() {
         dashboardHeightDebounceTask?.cancel()
         dashboardHeightDebounceTask = Task { @MainActor in

package/ios/Source/MentraBluetoothSDK.swift

@@ -147,6 +147,10 @@ private final class PendingResponse<T> {
 
 @MainActor
 public final class MentraBluetoothSDK {
+    private static let otaBesVersionWaitMs = 5_000
+    private static let otaMtkVersionWaitMs = 2_000
+    private static let otaVersionPollMs = 100
+
     public weak var delegate: MentraBluetoothSDKDelegate?
 
     private let configuration: MentraBluetoothSDKConfiguration
@@ -176,6 +180,7 @@ public final class MentraBluetoothSDK {
     private var pendingWifiStatus: PendingWifiStatusRequest?
     private var pendingHotspotStatus: PendingHotspotStatusRequest?
     private var pendingVersionInfo: PendingResponse<VersionInfoResult>?
+    private var configuredOtaVersionUrl: String?
 
     public init(configuration: MentraBluetoothSDKConfiguration = .default) {
         self.configuration = configuration
@@ -478,15 +483,66 @@ public final class MentraBluetoothSDK {
     }
 
     public func setButtonPhotoSettings(size: ButtonPhotoSize) async throws -> SettingsAckEvent {
-        try await performSettingsCommand(
-            setting: "button_photo",
-            updateStore: { _ in DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_photo_size", size.rawValue) },
-            send: { requestId in try DeviceManager.shared.sendButtonPhotoSettings(requestId: requestId, size: size.rawValue) }
-        )
+        try await setButtonPhotoSettings(ButtonPhotoSettings(size: size))
     }
 
     public func setButtonPhotoSettings(_ settings: ButtonPhotoSettings) async throws -> SettingsAckEvent {
-        try await setButtonPhotoSettings(size: settings.size)
+        try await performSettingsCommand(
+            setting: "button_photo",
+            updateStore: { _ in
+                if settings.resetCaptureTuning == true {
+                    // Mirror Android: clear all cached scan-tuning keys so reconnect sync
+                    // does not replay stale values after a reset.
+                    let cat = ObservableStore.bluetoothCategory
+                    for key in ["button_photo_mfnr", "button_photo_zsl", "button_photo_noise_reduction",
+                                "button_photo_edge_enhancement", "button_photo_isp_digital_gain",
+                                "button_photo_isp_analog_gain", "button_photo_ae_exposure_divisor",
+                                "button_photo_iso_cap", "button_photo_compress", "button_photo_sound"] {
+                        DeviceStore.shared.remove(cat, key)
+                    }
+                }
+                if let size = settings.size {
+                    DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_photo_size", size.rawValue)
+                }
+                if let mfnr = settings.mfnr {
+                    DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_photo_mfnr", mfnr)
+                }
+                if let zsl = settings.zsl {
+                    DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_photo_zsl", zsl)
+                }
+                if let noiseReduction = settings.noiseReduction {
+                    DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_photo_noise_reduction", noiseReduction)
+                }
+                if let edgeEnhancement = settings.edgeEnhancement {
+                    DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_photo_edge_enhancement", edgeEnhancement)
+                }
+                if let ispDigitalGain = settings.ispDigitalGain {
+                    DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_photo_isp_digital_gain", ispDigitalGain)
+                }
+                if let ispAnalogGain = settings.ispAnalogGain {
+                    DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_photo_isp_analog_gain", ispAnalogGain)
+                }
+                if let aeExposureDivisor = settings.aeExposureDivisor {
+                    DeviceStore.shared.set(
+                        ObservableStore.bluetoothCategory,
+                        "button_photo_ae_exposure_divisor",
+                        aeExposureDivisor
+                    )
+                }
+                if let isoCap = settings.isoCap {
+                    DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_photo_iso_cap", isoCap)
+                }
+                if let compress = settings.compress {
+                    DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_photo_compress", compress)
+                }
+                if let sound = settings.sound {
+                    DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_photo_sound", sound)
+                }
+            },
+            send: { requestId in
+                try DeviceManager.shared.sendButtonPhotoSettings(requestId: requestId, settings: settings)
+            }
+        )
     }
 
     public func setButtonVideoRecordingSettings(width: Int, height: Int, fps: Int) async throws -> SettingsAckEvent {
@@ -714,19 +770,7 @@ public final class MentraBluetoothSDK {
         )
         let pending = PendingResponse<PhotoResponseEvent>(operation: "photo request \(request.requestId)")
         pendingPhotoRequests[request.requestId] = pending
-        DeviceManager.shared.requestPhoto(
-            request.requestId,
-            request.appId,
-            request.size.rawValue,
-            request.webhookUrl,
-            request.authToken,
-            request.compress?.rawValue,
-            request.flash,
-            request.save,
-            request.sound,
-            exposureTimeNs: request.exposureTimeNs,
-            iso: request.iso
-        )
+        DeviceManager.shared.requestPhoto(request)
         do {
             let event = try await pending.wait()
             pendingPhotoRequests.removeValue(forKey: request.requestId)
@@ -926,8 +970,43 @@ public final class MentraBluetoothSDK {
         }
     }
 
-    /// Ask connected Mentra Live glasses to check/report OTA availability and status.
-    public func checkForOtaUpdate() async throws -> OtaQueryResult {
+    func setOtaVersionUrl(_ otaVersionUrl: String) throws {
+        configuredOtaVersionUrl = try OtaManifestChecker.normalizeHttpUrl(otaVersionUrl)
+    }
+
+    func getOtaVersionUrl() throws -> String {
+        try configuredOtaVersionUrl ?? OtaManifestDefaults.defaultOtaVersionUrl()
+    }
+
+    /// Fetch the configured OTA manifest and return whether any ASG/BES/MTK update is available.
+    public func checkForOtaUpdate() async throws -> Bool {
+        let status = await getFreshGlassesStatus()
+        guard status.connected else {
+            throw BluetoothError(
+                code: "glasses_not_connected",
+                message: "Cannot check OTA update because glasses are not connected."
+            )
+        }
+        guard !status.buildNumber.isEmpty else {
+            throw BluetoothError(
+                code: "missing_glasses_version",
+                message: "Cannot check OTA update because glasses build number is unavailable."
+            )
+        }
+
+        let manifestUrl = try resolveOtaVersionUrl(status: status)
+        let manifest = try await OtaManifestChecker.fetch(manifestUrl)
+        let otaStatus = try await waitForOtaManifestStatus(status, manifest: manifest)
+        return try OtaManifestChecker.hasUpdate(
+            currentBuildNumber: otaStatus.buildNumber,
+            currentMtkVersion: otaStatus.mtkFirmwareVersion,
+            currentBesVersion: otaStatus.besFirmwareVersion,
+            manifest: manifest
+        )
+    }
+
+    /// Ask connected Mentra Live glasses to report the current OTA install/session status.
+    private func queryOtaStatus() async throws -> OtaQueryResult {
         try await performOtaQuery(operation: "OTA status query") {
             DeviceManager.shared.sendOtaQueryStatus()
         }
@@ -962,6 +1041,12 @@ public final class MentraBluetoothSDK {
 
     /// Start the OTA flow after your app has presented the available update to the user.
     public func startOtaUpdate() async throws -> OtaStartAckEvent {
+        let status = await getFreshGlassesStatus()
+        let otaVersionUrl = try resolveOtaVersionUrl(status: status)
+        return try await startOtaUpdate(otaVersionUrl: otaVersionUrl)
+    }
+
+    private func startOtaCommand(otaVersionUrl: String) async throws -> OtaStartAckEvent {
         if pendingOtaStart != nil {
             throw BluetoothError(
                 code: "request_in_flight",
@@ -970,7 +1055,7 @@ public final class MentraBluetoothSDK {
         }
         let pending = PendingResponse<OtaStartAckEvent>(operation: "OTA start command")
         pendingOtaStart = pending
-        DeviceManager.shared.sendOtaStart()
+        DeviceManager.shared.sendOtaStart(otaVersionUrl: otaVersionUrl)
         do {
             let event = try await pending.wait()
             if pendingOtaStart === pending {
@@ -985,16 +1070,102 @@ public final class MentraBluetoothSDK {
         }
     }
 
-    /// Re-run the glasses-side OTA version check, mainly after correcting clock skew/TLS failures.
-    public func retryOtaVersionCheck() async throws -> OtaQueryResult {
+    func startOtaUpdate(otaVersionUrl: String) async throws -> OtaStartAckEvent {
+        try await startOtaCommand(otaVersionUrl: otaVersionUrl)
+    }
+
+    func sendOtaQueryStatus() async throws -> OtaQueryResult { try await queryOtaStatus() }
+
+    /// Re-run the glasses-side OTA version check after an internal clock-skew recovery.
+    func retryOtaVersionCheck() async throws -> OtaQueryResult {
         try await performOtaQuery(operation: "OTA version retry") {
             DeviceManager.shared.retryOtaVersionCheck()
         }
     }
 
-    func sendOtaStart() async throws -> OtaStartAckEvent { try await startOtaUpdate() }
+    private func getFreshGlassesStatus() async -> GlassesStatus {
+        let status = glassesStatus
+        if !status.connected || !status.buildNumber.isEmpty {
+            return status
+        }
 
-    func sendOtaQueryStatus() async throws -> OtaQueryResult { try await checkForOtaUpdate() }
+        do {
+            let versionInfo = try await requestVersionInfo()
+            let values = status.values.merging(versionInfo.dictionary) { existing, new in
+                if let newString = new as? String, newString.isEmpty {
+                    return existing
+                }
+                return new
+            }
+            return GlassesStatus(values: values)
+        } catch {
+            return status
+        }
+    }
+
+    private func waitForOtaManifestStatus(_ initialStatus: GlassesStatus, manifest: OtaManifest) async throws -> GlassesStatus {
+        var status = initialStatus
+        if OtaManifestChecker.hasBesFirmware(manifest), status.besFirmwareVersion.isEmpty {
+            status = await waitForGlassesStatus(status, timeoutMs: Self.otaBesVersionWaitMs) {
+                !$0.connected || !$0.besFirmwareVersion.isEmpty
+            }
+        }
+
+        if OtaManifestChecker.hasMtkPatches(manifest), status.mtkFirmwareVersion.isEmpty {
+            status = await waitForGlassesStatus(status, timeoutMs: Self.otaMtkVersionWaitMs) {
+                !$0.connected || !$0.mtkFirmwareVersion.isEmpty
+            }
+        }
+
+        guard status.connected else {
+            throw BluetoothError(
+                code: "glasses_not_connected",
+                message: "Cannot check OTA update because glasses disconnected."
+            )
+        }
+        return status
+    }
+
+    private func waitForGlassesStatus(
+        _ initialStatus: GlassesStatus,
+        timeoutMs: Int,
+        isReady: (GlassesStatus) -> Bool
+    ) async -> GlassesStatus {
+        let deadline = Date().addingTimeInterval(Double(timeoutMs) / 1_000)
+        var status = initialStatus
+        while Date() < deadline {
+            status = glassesStatus
+            if isReady(status) {
+                return status
+            }
+
+            let remainingMs = max(0, Int(deadline.timeIntervalSinceNow * 1_000))
+            let sleepMs = min(Self.otaVersionPollMs, remainingMs)
+            if sleepMs <= 0 {
+                break
+            }
+            try? await Task.sleep(nanoseconds: UInt64(sleepMs) * 1_000_000)
+        }
+        return glassesStatus
+    }
+
+    private func resolveOtaVersionUrl(status: GlassesStatus) throws -> String {
+        let deviceUrl = status.otaVersionUrl.trimmingCharacters(in: .whitespacesAndNewlines)
+        if isLegacyAsgOtaStartBuild(status.buildNumber) {
+            return deviceUrl.isEmpty ? OtaManifestDefaults.prodOtaVersionUrl : deviceUrl
+        }
+        // SDK consumers are pinned to the manifest built for their SDK version.
+        // A future glasses-advertised URL should not silently change that pairing.
+        if let configuredOtaVersionUrl {
+            return configuredOtaVersionUrl
+        }
+        return try OtaManifestDefaults.defaultOtaVersionUrl()
+    }
+
+    private func isLegacyAsgOtaStartBuild(_ buildNumber: String) -> Bool {
+        guard let parsed = Int(buildNumber) else { return false }
+        return parsed < 100_000
+    }
 
     func sendShutdown() {
         DeviceManager.shared.sendShutdown()

package/ios/Source/MentraBluetoothSDKDebug.swift

@@ -0,0 +1,12 @@
+import Foundation
+
+@MainActor
+public enum MentraBluetoothSDKDebug {
+    public static func setOtaVersionUrl(_ otaVersionUrl: String, on sdk: MentraBluetoothSDK) throws {
+        try sdk.setOtaVersionUrl(otaVersionUrl)
+    }
+
+    public static func getOtaVersionUrl(on sdk: MentraBluetoothSDK) throws -> String {
+        try sdk.getOtaVersionUrl()
+    }
+}

package/ios/Source/ObservableStore.swift

@@ -54,6 +54,17 @@ class ObservableStore {
         }
     }
 
+    func remove(_ category: String, _ key: String) {
+        let normalizedCategory = Self.normalizeCategory(category)
+        let fullKey = "\(normalizedCategory).\(key)"
+        guard values[fullKey] != nil else { return }
+        values.removeValue(forKey: fullKey)
+        // Emit updated category snapshot so UI listeners clear the removed key
+        let snapshot = getCategory(normalizedCategory)
+        onEmit?(normalizedCategory, snapshot)
+        for listener in Array(listeners.values) { listener(normalizedCategory, snapshot) }
+    }
+
     func get(_ category: String, _ key: String) -> Any? {
         values["\(Self.normalizeCategory(category)).\(key)"]
     }

package/ios/Source/OtaManifest.swift

@@ -0,0 +1,170 @@
+import Foundation
+
+enum OtaManifestDefaults {
+    private static let sdkOtaReleaseBaseUrl = "https://github.com/Mentra-Community/MentraOS/releases/download/bluetooth-sdk-ota"
+    // Keep prod as the legacy-device fallback: pre-override ASG builds ignore
+    // ota_start.ota_version_url and use their compiled MentraOS default.
+    static let prodOtaVersionUrl = "https://ota.mentraglass.com/prod_live_version.json"
+
+    static func defaultOtaVersionUrl() throws -> String {
+        guard let sdkVersion = BluetoothSdkDefaults.sdkVersion,
+              !sdkVersion.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
+        else {
+            throw BluetoothError(
+                code: "missing_sdk_version",
+                message: "Cannot determine Bluetooth SDK version for the default OTA manifest URL."
+            )
+        }
+        return "\(sdkOtaReleaseBaseUrl)/bluetooth-sdk-\(sdkVersion)-version.json"
+    }
+}
+
+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 BluetoothError(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 BluetoothError(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 BluetoothError(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 BluetoothError(code: "ota_manifest_request_failed", message: "OTA manifest request failed.")
+        }
+        guard (200 ... 299).contains(httpResponse.statusCode) else {
+            throw BluetoothError(
+                code: "ota_manifest_request_failed",
+                message: "OTA manifest request failed with HTTP \(httpResponse.statusCode)."
+            )
+        }
+        return try JSONDecoder().decode(OtaManifest.self, from: data)
+    }
+
+    static func hasUpdate(
+        currentBuildNumber: String,
+        currentMtkVersion: String,
+        currentBesVersion: String,
+        manifest: OtaManifest
+    ) throws -> Bool {
+        try hasApkUpdate(currentBuildNumber: currentBuildNumber, manifest: manifest) ||
+            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 BluetoothError(code: "invalid_ota_manifest", message: "OTA manifest is missing ASG app versionCode.")
+    }
+
+    private static func hasApkUpdate(currentBuildNumber: String, manifest: OtaManifest) throws -> Bool {
+        guard let currentVersion = Int(currentBuildNumber) else {
+            throw BluetoothError(
+                code: "invalid_glasses_version",
+                message: "Cannot check OTA update because glasses build number is invalid."
+            )
+        }
+        guard let serverVersion = try latestAppInfo(manifest).versionCode else {
+            throw BluetoothError(code: "invalid_ota_manifest", message: "OTA manifest is missing ASG app versionCode.")
+        }
+        return serverVersion > currentVersion
+    }
+
+    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 BluetoothError(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
+    }
+}