@mentra/bluetooth-sdk 0.1.12 → 0.1.14

package/android/src/main/java/com/mentra/bluetoothsdk/MentraBluetoothSdk.kt

@@ -45,6 +45,7 @@ class MentraBluetoothSdk private constructor(
     private var pendingWifiStatus: PendingWifiStatusRequest? = null
     private var pendingHotspotStatus: PendingHotspotStatusRequest? = null
     private var pendingVersionInfo: PendingResponse<VersionInfoResult>? = null
+    @Volatile private var configuredOtaVersionUrl: String? = null
 
     init {
         listeners.add(listener)
@@ -68,6 +69,9 @@ class MentraBluetoothSdk private constructor(
         private const val VIDEO_UPLOAD_STOP_TIMEOUT_MS = 10 * 60 * 1000L
         private const val STREAM_START_TIMEOUT_MS = 30_000L
         private const val STREAM_STOP_TIMEOUT_MS = 15_000L
+        private const val OTA_BES_VERSION_WAIT_MS = 5_000L
+        private const val OTA_MTK_VERSION_WAIT_MS = 2_000L
+        private const val OTA_VERSION_POLL_MS = 100L
         private const val DEFAULT_STREAM_KEEP_ALIVE_INTERVAL_SECONDS = 5
         private const val MAX_MISSED_STREAM_KEEP_ALIVE_ACKS = 3
 
@@ -470,40 +474,73 @@ class MentraBluetoothSdk private constructor(
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "voice_activity_detection_enabled", enabled)
     }
 
-    fun setButtonPhotoSettings(size: ButtonPhotoSize): SettingsAckEvent =
+    fun setPhotoCaptureDefaults(settings: PhotoCaptureDefaults): SettingsAckEvent =
         performSettingsCommand(
             setting = "button_photo",
-            updateStore = { _ -> DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_size", size.value) },
-            send = { requestId -> deviceManager.sendButtonPhotoSettings(requestId, size.value) },
+            updateStore = { _ ->
+                if (settings.resetCaptureTuning) {
+                    // Clear all stored scan-tuning keys from phone cache
+                    listOf(
+                        "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",
+                    ).forEach { key ->
+                        DeviceStore.store.remove(ObservableStore.BLUETOOTH_CATEGORY, key)
+                    }
+                }
+                // Only update size if explicitly provided; omitted size = leave stored value unchanged
+                settings.size?.let { DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_size", it.value) }
+                settings.mfnr?.let { DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_mfnr", it) }
+                settings.zsl?.let { DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_zsl", it) }
+                settings.noiseReduction?.let {
+                    DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_noise_reduction", it)
+                }
+                settings.edgeEnhancement?.let {
+                    DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_edge_enhancement", it)
+                }
+                settings.ispDigitalGain?.let {
+                    DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_isp_digital_gain", it)
+                }
+                settings.ispAnalogGain?.let {
+                    DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_isp_analog_gain", it)
+                }
+                settings.aeExposureDivisor?.let {
+                    DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_ae_exposure_divisor", it)
+                }
+                settings.isoCap?.let {
+                    DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_iso_cap", it)
+                }
+                settings.compress?.let {
+                    DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_compress", it)
+                }
+                settings.sound?.let {
+                    DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_photo_sound", it)
+                }
+            },
+            send = { requestId -> deviceManager.sendButtonPhotoSettings(requestId, settings) },
         )
 
-    fun setButtonPhotoSettings(settings: ButtonPhotoSettings): SettingsAckEvent =
-        setButtonPhotoSettings(size = settings.size)
-
-    fun setButtonVideoRecordingSettings(width: Int, height: Int, fps: Int): SettingsAckEvent =
+    fun setVideoRecordingDefaults(defaults: VideoRecordingDefaults): SettingsAckEvent =
         performSettingsCommand(
             setting = "button_video_recording",
             updateStore = { _ ->
-                DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_width", width)
-                DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_height", height)
-                DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_fps", fps)
+                DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_width", defaults.width)
+                DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_height", defaults.height)
+                DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_video_fps", defaults.fps)
             },
             send = { requestId ->
-                deviceManager.sendButtonVideoRecordingSettings(requestId, width, height, fps)
+                deviceManager.sendButtonVideoRecordingSettings(requestId, defaults.width, defaults.height, defaults.fps)
             },
         )
 
-    fun setButtonVideoRecordingSettings(settings: ButtonVideoRecordingSettings): SettingsAckEvent =
-        setButtonVideoRecordingSettings(width = settings.width, height = settings.height, fps = settings.fps)
-
-    fun setButtonCameraLed(enabled: Boolean): SettingsAckEvent =
-        performSettingsCommand(
-            setting = "button_camera_led",
-            updateStore = { _ -> DeviceStore.set(ObservableStore.BLUETOOTH_CATEGORY, "button_camera_led", enabled) },
-            send = { requestId -> deviceManager.sendButtonCameraLedSetting(requestId, enabled) },
-        )
-
-    fun setButtonMaxRecordingTime(minutes: Int): SettingsAckEvent =
+    fun setMaxVideoRecordingDuration(minutes: Int): SettingsAckEvent =
         performSettingsCommand(
             setting = "button_max_recording_time",
             updateStore = { _ ->
@@ -677,19 +714,7 @@ class MentraBluetoothSdk private constructor(
         val pending = PendingResponse<PhotoResponseEvent>("photo request ${request.requestId}")
         pendingPhotoRequests[request.requestId] = pending
         try {
-            deviceManager.requestPhoto(
-                request.requestId,
-                request.appId,
-                request.size.value,
-                request.webhookUrl,
-                request.authToken,
-                request.compress.value,
-                request.flash,
-                request.save,
-                request.sound,
-                request.exposureTimeNs,
-                request.iso,
-            )
+            deviceManager.requestPhoto(request)
             return pending.await()
         } finally {
             pendingPhotoRequests.remove(request.requestId, pending)
@@ -719,7 +744,16 @@ class MentraBluetoothSdk private constructor(
         }
     }
 
-    fun startStream(request: StreamRequest): StreamStatusEvent {
+    fun startStream(request: StreamRequest): StreamStatusEvent =
+        startStream(request, startSdkKeepAlive = true)
+
+    internal fun startExternallyManagedStream(request: StreamRequest): StreamStatusEvent =
+        startStream(request, startSdkKeepAlive = false)
+
+    private fun startStream(
+        request: StreamRequest,
+        startSdkKeepAlive: Boolean,
+    ): StreamStatusEvent {
         val message = request.toMap().toMutableMap()
         val streamId = (message["streamId"] as? String)?.takeIf { it.isNotBlank() }
                 ?: "sdk-${UUID.randomUUID()}"
@@ -730,8 +764,8 @@ class MentraBluetoothSdk private constructor(
         try {
             deviceManager.startStream(message)
             val event = pending.await(STREAM_START_TIMEOUT_MS)
-            if (request.keepAlive && !request.isExternallyManagedKeepAlive()) {
-                startStreamKeepAliveMonitor(streamId, request.keepAliveIntervalSeconds)
+            if (startSdkKeepAlive) {
+                startStreamKeepAliveMonitor(streamId, DEFAULT_STREAM_KEEP_ALIVE_INTERVAL_SECONDS)
             }
             return event
         } finally {
@@ -871,8 +905,41 @@ class MentraBluetoothSdk private constructor(
         }
     }
 
-    /** Ask connected Mentra Live glasses to check/report OTA availability and status. */
-    fun checkForOtaUpdate(): OtaQueryResult =
+    internal fun setOtaVersionUrl(otaVersionUrl: String) {
+        configuredOtaVersionUrl = OtaManifestChecker.normalizeHttpUrl(otaVersionUrl)
+    }
+
+    internal fun getOtaVersionUrl(): String = configuredOtaVersionUrl ?: OtaManifestDefaults.defaultOtaVersionUrl()
+
+    /** Fetch the configured OTA manifest and return whether any ASG/BES/MTK update is available. */
+    fun checkForOtaUpdate(): Boolean {
+        val status = getFreshGlassesStatus()
+        if (!status.connected) {
+            throw BluetoothException(
+                "glasses_not_connected",
+                "Cannot check OTA update because glasses are not connected.",
+            )
+        }
+        if (status.buildNumber.isBlank()) {
+            throw BluetoothException(
+                "missing_glasses_version",
+                "Cannot check OTA update because glasses build number is unavailable.",
+            )
+        }
+
+        val manifestUrl = resolveOtaVersionUrl(status)
+        val manifest = OtaManifestChecker.fetch(manifestUrl)
+        val otaStatus = waitForOtaManifestStatus(status, manifest)
+        return OtaManifestChecker.hasUpdate(
+            otaStatus.buildNumber,
+            otaStatus.mtkFirmwareVersion,
+            otaStatus.besFirmwareVersion,
+            manifest,
+        )
+    }
+
+    /** Ask connected Mentra Live glasses to report the current OTA install/session status. */
+    private fun queryOtaStatus(): OtaQueryResult =
         performOtaQuery("OTA status query") {
             deviceManager.sendOtaQueryStatus()
         }
@@ -905,6 +972,11 @@ class MentraBluetoothSdk private constructor(
 
     /** Start the OTA flow after your app has presented the available update to the user. */
     fun startOtaUpdate(): OtaStartAckEvent {
+        val otaVersionUrl = resolveOtaVersionUrl(getFreshGlassesStatus())
+        return startOtaUpdate(otaVersionUrl)
+    }
+
+    private fun startOtaCommand(otaVersionUrl: String): OtaStartAckEvent {
         val pending = PendingResponse<OtaStartAckEvent>("OTA start command")
         synchronized(oneShotLock) {
             if (pendingOtaStart != null) {
@@ -916,7 +988,7 @@ class MentraBluetoothSdk private constructor(
             pendingOtaStart = pending
         }
         try {
-            deviceManager.sendOtaStart()
+            deviceManager.sendOtaStart(otaVersionUrl)
             return pending.await()
         } finally {
             synchronized(oneShotLock) {
@@ -927,15 +999,98 @@ class MentraBluetoothSdk private constructor(
         }
     }
 
-    /** Re-run the glasses-side OTA version check, mainly after correcting clock skew/TLS failures. */
-    fun retryOtaVersionCheck(): OtaQueryResult =
+    internal fun startOtaUpdate(otaVersionUrl: String): OtaStartAckEvent =
+        startOtaCommand(otaVersionUrl)
+
+    internal fun sendOtaQueryStatus(): OtaQueryResult = queryOtaStatus()
+
+    /** Re-run the glasses-side OTA version check after an internal clock-skew recovery. */
+    @JvmSynthetic
+    internal fun retryOtaVersionCheck(): OtaQueryResult =
         performOtaQuery("OTA version retry") {
             deviceManager.retryOtaVersionCheck()
         }
 
-    internal fun sendOtaStart(): OtaStartAckEvent = startOtaUpdate()
+    private fun getFreshGlassesStatus(): GlassesStatus {
+        val status = getRawGlassesStatus()
+        if (!status.connected || status.buildNumber.isNotBlank()) {
+            return status
+        }
+
+        return try {
+            val versionInfo = requestVersionInfo()
+            status.copy(
+                androidVersion = versionInfo.androidVersion.ifBlank { status.androidVersion },
+                firmwareVersion = versionInfo.firmwareVersion.ifBlank { status.firmwareVersion },
+                besFirmwareVersion = versionInfo.besFirmwareVersion.ifBlank { status.besFirmwareVersion },
+                mtkFirmwareVersion = versionInfo.mtkFirmwareVersion.ifBlank { status.mtkFirmwareVersion },
+                buildNumber = versionInfo.buildNumber.ifBlank { status.buildNumber },
+                systemTimeMs = versionInfo.systemTimeMs ?: status.systemTimeMs,
+                otaVersionUrl = versionInfo.otaVersionUrl.ifBlank { status.otaVersionUrl },
+                appVersion = versionInfo.appVersion.ifBlank { status.appVersion },
+            )
+        } catch (_: Throwable) {
+            status
+        }
+    }
+
+    private fun waitForOtaManifestStatus(
+        initialStatus: GlassesStatus,
+        manifest: org.json.JSONObject,
+    ): GlassesStatus {
+        var status = initialStatus
+        if (OtaManifestChecker.hasBesFirmware(manifest) && status.besFirmwareVersion.isBlank()) {
+            status = waitForGlassesStatus(status, OTA_BES_VERSION_WAIT_MS) {
+                !it.connected || it.besFirmwareVersion.isNotBlank()
+            }
+        }
+
+        if (OtaManifestChecker.hasMtkPatches(manifest) && status.mtkFirmwareVersion.isBlank()) {
+            status = waitForGlassesStatus(status, OTA_MTK_VERSION_WAIT_MS) {
+                !it.connected || it.mtkFirmwareVersion.isNotBlank()
+            }
+        }
+
+        if (!status.connected) {
+            throw BluetoothException(
+                "glasses_not_connected",
+                "Cannot check OTA update because glasses disconnected.",
+            )
+        }
+        return status
+    }
+
+    private fun waitForGlassesStatus(
+        initialStatus: GlassesStatus,
+        timeoutMs: Long,
+        isReady: (GlassesStatus) -> Boolean,
+    ): GlassesStatus {
+        val deadline = System.currentTimeMillis() + timeoutMs
+        var status = initialStatus
+        while (System.currentTimeMillis() < deadline) {
+            status = getRawGlassesStatus()
+            if (isReady(status)) return status
+            val remainingMs = deadline - System.currentTimeMillis()
+            if (remainingMs <= 0L) break
+            Thread.sleep(minOf(OTA_VERSION_POLL_MS, remainingMs))
+        }
+        return getRawGlassesStatus()
+    }
+
+    private fun resolveOtaVersionUrl(status: GlassesStatus): String {
+        val deviceUrl = status.otaVersionUrl.trim()
+        if (isLegacyAsgOtaStartBuild(status.buildNumber)) {
+            return deviceUrl.ifBlank { OtaManifestDefaults.PROD_OTA_VERSION_URL }
+        }
+        // SDK consumers are pinned to the manifest built for their SDK version.
+        // A future glasses-advertised URL should not silently change that pairing.
+        return configuredOtaVersionUrl ?: OtaManifestDefaults.defaultOtaVersionUrl()
+    }
 
-    internal fun sendOtaQueryStatus(): OtaQueryResult = checkForOtaUpdate()
+    private fun isLegacyAsgOtaStartBuild(buildNumber: String): Boolean {
+        val parsed = buildNumber.toIntOrNull()
+        return parsed != null && parsed < 100_000
+    }
 
     internal fun sendShutdown() {
         deviceManager.sendShutdown()
@@ -1333,6 +1488,14 @@ class MentraBluetoothSdk private constructor(
             return streamId to pending
         }
         if (pendingStreamStarts.size == 1) {
+            // A streamId-less STOPPED is the glasses' stop-ack for a PREVIOUS
+            // stream (their stop ack carries no streamId), not a verdict on the
+            // pending start — a start_stream that replaces a running publisher
+            // emits exactly this sequence (stopped -> initializing -> streaming).
+            // Attributing it here would reject a start that is about to succeed.
+            if (event.state == StreamState.STOPPED) {
+                return null
+            }
             val entry = pendingStreamStarts.entries.first()
             return entry.key to entry.value
         }

package/android/src/main/java/com/mentra/bluetoothsdk/MentraBluetoothSdkDebug.kt

@@ -0,0 +1,14 @@
+package com.mentra.bluetoothsdk
+
+object MentraBluetoothSdkDebug {
+    @JvmStatic
+    fun setOtaVersionUrl(
+        sdk: MentraBluetoothSdk,
+        otaVersionUrl: String,
+    ) {
+        sdk.setOtaVersionUrl(otaVersionUrl)
+    }
+
+    @JvmStatic
+    fun getOtaVersionUrl(sdk: MentraBluetoothSdk): String = sdk.getOtaVersionUrl()
+}

package/android/src/main/java/com/mentra/bluetoothsdk/ObservableStore.kt

@@ -53,6 +53,26 @@ class ObservableStore {
         listeners.forEach { it(normalizedCategory, mapOf(key to value)) }
     }
 
+    fun remove(category: String, key: String) {
+        val normalizedCategory: String
+        val updatedSnapshot: Map<String, Any>
+        val listeners: List<(String, Map<String, Any>) -> Unit>
+
+        synchronized(this) {
+            normalizedCategory = normalizeCategory(category)
+            val fullKey = "$normalizedCategory.$key"
+            if (!values.containsKey(fullKey)) return // already absent, no notification needed
+            values.remove(fullKey)
+            val prefix = "$normalizedCategory."
+            updatedSnapshot = values.filterKeys { it.startsWith(prefix) }
+                    .mapKeys { it.key.removePrefix(prefix) }
+            listeners = emitListeners.values.toList()
+        }
+
+        // Emit the full updated category snapshot so UI listeners can clear the removed key.
+        listeners.forEach { it(normalizedCategory, updatedSnapshot) }
+    }
+
     @Synchronized
     fun get(category: String, key: String): Any? = values["${normalizeCategory(category)}.$key"]
 

package/android/src/main/java/com/mentra/bluetoothsdk/OtaManifest.kt

@@ -0,0 +1,153 @@
+package com.mentra.bluetoothsdk
+
+import java.net.HttpURLConnection
+import java.net.URI
+import java.net.URL
+import org.json.JSONArray
+import org.json.JSONObject
+
+internal object OtaManifestDefaults {
+    private const val SDK_OTA_RELEASE_BASE_URL =
+        "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.
+    const val PROD_OTA_VERSION_URL = "https://ota.mentraglass.com/prod_live_version.json"
+
+    fun defaultOtaVersionUrl(): String {
+        val sdkVersion = BuildConfig.SDK_VERSION.trim()
+        if (sdkVersion.isBlank() || sdkVersion == "unspecified") {
+            throw BluetoothException(
+                "missing_sdk_version",
+                "Cannot determine Bluetooth SDK version for the default OTA manifest URL.",
+            )
+        }
+        return "$SDK_OTA_RELEASE_BASE_URL/bluetooth-sdk-$sdkVersion-version.json"
+    }
+}
+
+internal object OtaManifestChecker {
+    private const val ASG_CLIENT_PACKAGE = "com.mentra.asg_client"
+
+    fun normalizeHttpUrl(value: String): String {
+        val trimmed = value.trim()
+        if (trimmed.isEmpty()) {
+            throw BluetoothException("invalid_ota_url", "OTA version URL must be a non-empty http(s) URL.")
+        }
+
+        val uri =
+            try {
+                URI(trimmed)
+            } catch (error: Exception) {
+                throw BluetoothException("invalid_ota_url", "OTA version URL must be a valid http(s) URL.", error)
+            }
+
+        val scheme = uri.scheme?.lowercase()
+        if ((scheme != "http" && scheme != "https") || uri.host.isNullOrBlank()) {
+            throw BluetoothException("invalid_ota_url", "OTA version URL must be an http(s) URL.")
+        }
+
+        return uri.toString()
+    }
+
+    fun fetch(otaVersionUrl: String): JSONObject {
+        val connection = URL(otaVersionUrl).openConnection() as HttpURLConnection
+        connection.connectTimeout = 15_000
+        connection.readTimeout = 15_000
+        connection.requestMethod = "GET"
+        return try {
+            val status = connection.responseCode
+            if (status !in 200..299) {
+                throw BluetoothException("ota_manifest_request_failed", "OTA manifest request failed with HTTP $status.")
+            }
+            JSONObject(connection.inputStream.bufferedReader().use { it.readText() })
+        } finally {
+            connection.disconnect()
+        }
+    }
+
+    fun hasUpdate(
+        currentBuildNumber: String,
+        currentMtkVersion: String,
+        currentBesVersion: String,
+        manifest: JSONObject,
+    ): Boolean =
+        hasApkUpdate(currentBuildNumber, manifest) ||
+            hasMtkUpdate(manifest.optJSONArray("mtk_patches"), currentMtkVersion) ||
+            hasBesUpdate(manifest.optJSONObject("bes_firmware"), currentBesVersion)
+
+    fun hasMtkPatches(manifest: JSONObject): Boolean =
+        (manifest.optJSONArray("mtk_patches")?.length() ?: 0) > 0
+
+    fun hasBesFirmware(manifest: JSONObject): Boolean =
+        manifest.optJSONObject("bes_firmware") != null
+
+    private fun latestAppInfo(manifest: JSONObject): JSONObject {
+        val apps = manifest.optJSONObject("apps")
+        val app = apps?.optJSONObject(ASG_CLIENT_PACKAGE)
+        if (app != null && app.hasNumber("versionCode")) {
+            return app
+        }
+
+        if (manifest.hasNumber("versionCode")) {
+            return manifest
+        }
+
+        throw BluetoothException("invalid_ota_manifest", "OTA manifest is missing ASG app versionCode.")
+    }
+
+    private fun hasApkUpdate(currentBuildNumber: String, manifest: JSONObject): Boolean {
+        val currentVersion =
+            currentBuildNumber.toLongOrNull()
+                ?: throw BluetoothException(
+                    "invalid_glasses_version",
+                    "Cannot check OTA update because glasses build number is invalid.",
+                )
+        val serverVersion = latestAppInfo(manifest).requiredLong("versionCode")
+        return serverVersion > currentVersion
+    }
+
+    private fun hasMtkUpdate(patches: JSONArray?, currentVersion: String): Boolean {
+        if (patches == null || patches.length() == 0) return false
+        if (currentVersion.isBlank()) return false
+
+        for (index in 0 until patches.length()) {
+            val patch = patches.optJSONObject(index) ?: continue
+            val startFirmware = patch.optString("start_firmware", "")
+            if (startFirmware == currentVersion) return true
+            val serverDate = if (startFirmware.contains("_")) startFirmware.substringAfterLast("_") else startFirmware
+            if (serverDate == currentVersion) return true
+        }
+        return false
+    }
+
+    private fun hasBesUpdate(besFirmware: JSONObject?, currentVersion: String): Boolean {
+        if (besFirmware == null) return false
+        val serverVersion = besFirmware.optString("version", "")
+        if (serverVersion.isBlank()) {
+            throw BluetoothException("invalid_ota_manifest", "OTA manifest bes_firmware.version is missing.")
+        }
+        if (currentVersion.isBlank()) return true
+        return compareVersions(serverVersion, currentVersion) > 0
+    }
+
+    private fun compareVersions(version1: String, version2: String): Int {
+        if (version1.contains(".") && version2.contains(".")) {
+            val parts1 = version1.split(".")
+            val parts2 = version2.split(".")
+            val maxLength = maxOf(parts1.size, parts2.size)
+            for (index in 0 until maxLength) {
+                val value1 = parts1.getOrNull(index)?.toIntOrNull() ?: 0
+                val value2 = parts2.getOrNull(index)?.toIntOrNull() ?: 0
+                if (value1 != value2) return value1 - value2
+            }
+            return 0
+        }
+        return version1.compareTo(version2)
+    }
+
+    private fun JSONObject.hasNumber(key: String): Boolean = !isNull(key) && opt(key) is Number
+
+    private fun JSONObject.requiredLong(key: String): Long =
+        (opt(key) as? Number)?.toLong()
+            ?: throw BluetoothException("invalid_ota_manifest", "OTA manifest is missing ASG app versionCode.")
+}