@mentra/bluetooth-sdk 0.1.12 → 0.1.14

package/ios/Source/MentraBluetoothSDK.swift

@@ -147,6 +147,11 @@ 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
+    private static let defaultStreamKeepAliveIntervalSeconds = 5
+
     public weak var delegate: MentraBluetoothSDKDelegate?
 
     private let configuration: MentraBluetoothSDKConfiguration
@@ -176,6 +181,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
@@ -477,50 +483,85 @@ public final class MentraBluetoothSDK {
         DeviceStore.shared.apply(ObservableStore.bluetoothCategory, "voice_activity_detection_enabled", enabled)
     }
 
-    public func setButtonPhotoSettings(size: ButtonPhotoSize) async throws -> SettingsAckEvent {
+    public func setPhotoCaptureDefaults(_ settings: PhotoCaptureDefaults) 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) }
+            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 setButtonPhotoSettings(_ settings: ButtonPhotoSettings) async throws -> SettingsAckEvent {
-        try await setButtonPhotoSettings(size: settings.size)
-    }
-
-    public func setButtonVideoRecordingSettings(width: Int, height: Int, fps: Int) async throws -> SettingsAckEvent {
+    public func setVideoRecordingDefaults(_ defaults: VideoRecordingDefaults) async throws -> SettingsAckEvent {
         try await performSettingsCommand(
             setting: "button_video_recording",
             updateStore: { _ in
-                DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_video_width", width)
-                DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_video_height", height)
-                DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_video_fps", fps)
+                DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_video_width", defaults.width)
+                DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_video_height", defaults.height)
+                DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_video_fps", defaults.fps)
             },
             send: { requestId in
                 try DeviceManager.shared.sendButtonVideoRecordingSettings(
                     requestId: requestId,
-                    width: width,
-                    height: height,
-                    fps: fps
+                    width: defaults.width,
+                    height: defaults.height,
+                    fps: defaults.fps
                 )
             }
         )
     }
 
-    public func setButtonVideoRecordingSettings(_ settings: ButtonVideoRecordingSettings) async throws -> SettingsAckEvent {
-        try await setButtonVideoRecordingSettings(width: settings.width, height: settings.height, fps: settings.fps)
-    }
-
-    public func setButtonCameraLed(enabled: Bool) async throws -> SettingsAckEvent {
-        try await performSettingsCommand(
-            setting: "button_camera_led",
-            updateStore: { _ in DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_camera_led", enabled) },
-            send: { requestId in try DeviceManager.shared.sendButtonCameraLedSetting(requestId: requestId, enabled: enabled) }
-        )
-    }
-
-    public func setButtonMaxRecordingTime(minutes: Int) async throws -> SettingsAckEvent {
+    public func setMaxVideoRecordingDuration(minutes: Int) async throws -> SettingsAckEvent {
         try await performSettingsCommand(
             setting: "button_max_recording_time",
             updateStore: { _ in
@@ -714,19 +755,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)
@@ -762,6 +791,14 @@ public final class MentraBluetoothSDK {
     }
 
     public func startStream(_ request: StreamRequest) async throws -> StreamStatusEvent {
+        try await startStream(request, startSdkKeepAlive: true)
+    }
+
+    func startExternallyManagedStream(_ request: StreamRequest) async throws -> StreamStatusEvent {
+        try await startStream(request, startSdkKeepAlive: false)
+    }
+
+    private func startStream(_ request: StreamRequest, startSdkKeepAlive: Bool) async throws -> StreamStatusEvent {
         var values = request.values
         let streamId = stringValue(values, "streamId").flatMap { $0.isEmpty ? nil : $0 } ?? "sdk-\(UUID().uuidString)"
         values["streamId"] = streamId
@@ -772,8 +809,11 @@ public final class MentraBluetoothSDK {
         do {
             let event = try await pending.wait(timeoutMs: 30_000)
             pendingStreamStarts.removeValue(forKey: streamId)
-            if request.keepAlive, !request.isExternallyManagedKeepAlive {
-                startStreamKeepAliveMonitor(streamId: streamId, intervalSeconds: request.keepAliveIntervalSeconds)
+            if startSdkKeepAlive {
+                startStreamKeepAliveMonitor(
+                    streamId: streamId,
+                    intervalSeconds: Self.defaultStreamKeepAliveIntervalSeconds
+                )
             }
             return event
         } catch {
@@ -926,8 +966,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 +1037,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 +1051,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 +1066,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()
@@ -1103,7 +1270,7 @@ public final class MentraBluetoothSDK {
     }
 
     private func startStreamKeepAliveMonitor(streamId: String, intervalSeconds requestedIntervalSeconds: Int) {
-        let intervalSeconds = requestedIntervalSeconds > 0 ? requestedIntervalSeconds : 5
+        let intervalSeconds = requestedIntervalSeconds > 0 ? requestedIntervalSeconds : Self.defaultStreamKeepAliveIntervalSeconds
         let tracker = ActiveStreamKeepAlive(streamId: streamId, intervalSeconds: intervalSeconds)
         activeStreamKeepAlive = tracker
         sendNextStreamKeepAlive(for: tracker)

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
+    }
+}