@glassly/bluetooth-sdk 0.1.0-dev.26

package/android/src/main/java/com/glassly/bluetoothsdk/LocalNetworkModule.kt

@@ -0,0 +1,414 @@
+package com.glassly.bluetoothsdk
+
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import android.net.wifi.WifiNetworkSpecifier
+import android.os.Handler
+import android.os.Looper
+import android.util.Base64
+import android.util.Log
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.io.File
+import java.io.FileOutputStream
+import java.net.HttpURLConnection
+import java.net.Inet4Address
+import java.net.URL
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.Executors
+
+/** Glassly-internal transport for glasses-local traffic without process network binding. */
+class LocalNetworkModule : Module() {
+    private companion object {
+        const val TAG = "LocalNetwork"
+        const val NETWORK_READINESS_TIMEOUT_MS = 5_000L
+    }
+
+    private val lock = Any()
+    private val executor = Executors.newCachedThreadPool()
+    private val handler = Handler(Looper.getMainLooper())
+    private val activeConnections = ConcurrentHashMap<String, HttpURLConnection>()
+    private val networkReadiness = ScopedNetworkReadiness<Network>()
+    private var localNetwork: Network? = null
+    private var networkCallback: ConnectivityManager.NetworkCallback? = null
+    private var pendingConnectPromise: Promise? = null
+    private var pendingReadinessTimeout: Runnable? = null
+
+    override fun definition() = ModuleDefinition {
+        Name("LocalNetwork")
+        Events("downloadProgress", "networkLost")
+
+        AsyncFunction("connect") { ssid: String, password: String, promise: Promise ->
+            connect(ssid, password, promise)
+        }
+
+        AsyncFunction("request") {
+            requestId: String,
+            url: String,
+            method: String,
+            headers: Map<String, String>,
+            body: String?,
+            timeoutMs: Int,
+            promise: Promise ->
+            executor.execute { performRequest(requestId, url, method, headers, body, timeoutMs, promise) }
+        }
+
+        AsyncFunction("download") {
+            requestId: String,
+            url: String,
+            destination: String,
+            headers: Map<String, String>,
+            connectionTimeoutMs: Int,
+            readTimeoutMs: Int,
+            promise: Promise ->
+            executor.execute {
+                performDownload(
+                    requestId,
+                    url,
+                    destination,
+                    headers,
+                    connectionTimeoutMs,
+                    readTimeoutMs,
+                    promise,
+                )
+            }
+        }
+
+        AsyncFunction("cancel") { requestId: String -> cancel(requestId) }
+        AsyncFunction("disconnect") { disconnect() }
+
+        OnDestroy {
+            disconnect()
+        }
+    }
+
+    private fun connectivityManager(): ConnectivityManager =
+        requireNotNull(appContext.reactContext?.getSystemService(ConnectivityManager::class.java)) {
+            "ConnectivityManager is unavailable"
+        }
+
+    private fun connect(ssid: String, password: String, promise: Promise) {
+        disconnect()
+        val manager = connectivityManager()
+        val specifier =
+            WifiNetworkSpecifier.Builder()
+                .setSsid(ssid)
+                .setWpa2Passphrase(password)
+                .build()
+        val request =
+            NetworkRequest.Builder()
+                .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
+                .removeCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+                .setNetworkSpecifier(specifier)
+                .build()
+
+        val callback =
+            object : ConnectivityManager.NetworkCallback() {
+                override fun onAvailable(network: Network) {
+                    synchronized(lock) {
+                        if (networkCallback !== this) {
+                            Log.d(TAG, "Ignoring onAvailable from a stale network request")
+                            return
+                        }
+                        networkReadiness.onAvailable(network)
+                    }
+                    Log.i(
+                        TAG,
+                        "Captured glasses WiFi network=$network; waiting for foreground capability " +
+                            "processBoundNetwork=${manager.boundNetworkForProcess}",
+                    )
+                    scheduleReadinessTimeout(this, ssid)
+                }
+
+                override fun onCapabilitiesChanged(network: Network, capabilities: NetworkCapabilities) {
+                    val connectPromise: Promise?
+                    synchronized(lock) {
+                        if (networkCallback !== this || localNetwork != null || pendingConnectPromise == null) return
+                        if (!networkReadiness.isReady(
+                                network,
+                                capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_FOREGROUND),
+                            )
+                        ) {
+                            return
+                        }
+                        localNetwork = network
+                        connectPromise = pendingConnectPromise
+                        pendingConnectPromise = null
+                        cancelReadinessTimeoutLocked()
+                    }
+                    Log.i(
+                        TAG,
+                        "Glasses WiFi network=$network is foreground and ready " +
+                            "processBoundNetwork=${manager.boundNetworkForProcess}",
+                    )
+                    val localAddress =
+                        manager.getLinkProperties(network)
+                            ?.linkAddresses
+                            ?.firstOrNull { it.address is Inet4Address }
+                            ?.address
+                            ?.hostAddress
+                    connectPromise?.resolve(
+                        buildMap<String, Any> {
+                            put("connected", true)
+                            put("ssid", ssid)
+                            if (!localAddress.isNullOrBlank()) put("localAddress", localAddress)
+                        },
+                    )
+                }
+
+                override fun onUnavailable() {
+                    synchronized(lock) {
+                        if (networkCallback !== this) {
+                            Log.d(TAG, "Ignoring onUnavailable from a stale network request")
+                            return
+                        }
+                    }
+                    rejectPendingConnect("ERR_LOCAL_WIFI_UNAVAILABLE", "Could not connect to $ssid")
+                    clearNetworkCallback(this)
+                }
+
+                override fun onLost(network: Network) {
+                    synchronized(lock) {
+                        if (networkCallback !== this ||
+                            (localNetwork != network && !networkReadiness.contains(network))
+                        ) {
+                            Log.d(TAG, "Ignoring onLost from a stale network request")
+                            return
+                        }
+                        localNetwork = null
+                        networkReadiness.clear()
+                    }
+                    cancelAll()
+                    rejectPendingConnect("ERR_LOCAL_WIFI_LOST", "Lost connection to $ssid")
+                    clearNetworkCallback(this)
+                    sendEvent("networkLost", mapOf("ssid" to ssid))
+                }
+            }
+
+        synchronized(lock) {
+            pendingConnectPromise = promise
+            networkCallback = callback
+        }
+        try {
+            manager.requestNetwork(request, callback, 30_000)
+        } catch (error: Exception) {
+            clearNetworkCallback(callback)
+            rejectPendingConnect("ERR_LOCAL_WIFI_REQUEST", error.message ?: "Local WiFi request failed", error)
+        }
+    }
+
+    private fun performRequest(
+        requestId: String,
+        url: String,
+        method: String,
+        headers: Map<String, String>,
+        body: String?,
+        timeoutMs: Int,
+        promise: Promise,
+    ) {
+        var connection: HttpURLConnection? = null
+        try {
+            connection = openConnection(requestId, url)
+            connection.requestMethod = method
+            connection.connectTimeout = timeoutMs
+            connection.readTimeout = timeoutMs
+            headers.forEach(connection::setRequestProperty)
+            if (body != null) {
+                connection.doOutput = true
+                connection.outputStream.use { it.write(body.toByteArray(Charsets.UTF_8)) }
+            }
+            val status = connection.responseCode
+            val stream = if (status >= 400) connection.errorStream else connection.inputStream
+            val bytes = stream?.use { it.readBytes() } ?: ByteArray(0)
+            promise.resolve(
+                mapOf(
+                    "status" to status,
+                    "headers" to responseHeaders(connection),
+                    "bodyBase64" to Base64.encodeToString(bytes, Base64.NO_WRAP),
+                ),
+            )
+        } catch (error: Exception) {
+            promise.reject("ERR_LOCAL_HTTP", error.message ?: "Local HTTP request failed", error)
+        } finally {
+            activeConnections.remove(requestId)
+            connection?.disconnect()
+        }
+    }
+
+    private fun performDownload(
+        requestId: String,
+        url: String,
+        destination: String,
+        headers: Map<String, String>,
+        connectionTimeoutMs: Int,
+        readTimeoutMs: Int,
+        promise: Promise,
+    ) {
+        var connection: HttpURLConnection? = null
+        try {
+            connection = openConnection(requestId, url)
+            connection.requestMethod = "GET"
+            connection.connectTimeout = connectionTimeoutMs
+            connection.readTimeout = readTimeoutMs
+            headers.forEach(connection::setRequestProperty)
+            val status = connection.responseCode
+            if (status !in 200..299) throw IllegalStateException("HTTP $status")
+            val contentLength = connection.contentLengthLong
+            val responseHeaders = responseHeaders(connection)
+
+            // Match RNFS's begin callback contract before the first response byte. Gallery
+            // resumable downloads need the real status and Content-Range to validate segments.
+            sendEvent(
+                "downloadProgress",
+                mapOf(
+                    "requestId" to requestId,
+                    "bytesWritten" to 0L,
+                    "contentLength" to contentLength,
+                    "statusCode" to status,
+                    "headers" to responseHeaders,
+                ),
+            )
+
+            val destinationFile = File(destination)
+            destinationFile.parentFile?.mkdirs()
+            var bytesWritten = 0L
+            connection.inputStream.use { input ->
+                FileOutputStream(destinationFile, false).use { output ->
+                    val buffer = ByteArray(64 * 1024)
+                    while (true) {
+                        val count = input.read(buffer)
+                        if (count < 0) break
+                        output.write(buffer, 0, count)
+                        bytesWritten += count
+                        sendEvent(
+                            "downloadProgress",
+                            mapOf(
+                                "requestId" to requestId,
+                                "bytesWritten" to bytesWritten,
+                                "contentLength" to contentLength,
+                            ),
+                        )
+                    }
+                }
+            }
+            promise.resolve(
+                mapOf(
+                    "statusCode" to status,
+                    "bytesWritten" to bytesWritten,
+                    "headers" to responseHeaders,
+                ),
+            )
+        } catch (error: Exception) {
+            promise.reject("ERR_LOCAL_DOWNLOAD", error.message ?: "Local download failed", error)
+        } finally {
+            activeConnections.remove(requestId)
+            connection?.disconnect()
+        }
+    }
+
+    private fun openConnection(requestId: String, url: String): HttpURLConnection {
+        val network = synchronized(lock) { localNetwork }
+            ?: throw IllegalStateException("Local WiFi is not connected")
+        val connection = network.openConnection(URL(url)) as HttpURLConnection
+        activeConnections[requestId] = connection
+        return connection
+    }
+
+    private fun responseHeaders(connection: HttpURLConnection): Map<String, String> =
+        connection.headerFields
+            .filterKeys { it != null }
+            .mapValues { (_, values) -> values.joinToString(", ") }
+
+    private fun cancel(requestId: String) {
+        activeConnections.remove(requestId)?.disconnect()
+    }
+
+    private fun cancelAll() {
+        activeConnections.keys.toList().forEach(::cancel)
+    }
+
+    private fun scheduleReadinessTimeout(
+        callback: ConnectivityManager.NetworkCallback,
+        ssid: String,
+    ) {
+        val timeout =
+            Runnable {
+                val connectPromise = synchronized(lock) {
+                    if (networkCallback !== callback || pendingConnectPromise == null) return@Runnable
+                    pendingReadinessTimeout = null
+                    val promise = pendingConnectPromise
+                    pendingConnectPromise = null
+                    promise
+                }
+                connectPromise?.reject(
+                    "ERR_LOCAL_WIFI_NOT_READY",
+                    "Connected to $ssid but the network did not become ready",
+                    null,
+                )
+                clearNetworkCallback(callback)
+            }
+        synchronized(lock) {
+            if (networkCallback !== callback || pendingConnectPromise == null) return
+            cancelReadinessTimeoutLocked()
+            pendingReadinessTimeout = timeout
+        }
+        handler.postDelayed(timeout, NETWORK_READINESS_TIMEOUT_MS)
+    }
+
+    private fun cancelReadinessTimeoutLocked() {
+        pendingReadinessTimeout?.let(handler::removeCallbacks)
+        pendingReadinessTimeout = null
+    }
+
+    private fun disconnect() {
+        cancelAll()
+        val manager = appContext.reactContext?.getSystemService(ConnectivityManager::class.java)
+        val callback: ConnectivityManager.NetworkCallback?
+        synchronized(lock) {
+            callback = networkCallback
+            networkCallback = null
+            localNetwork = null
+            networkReadiness.clear()
+            cancelReadinessTimeoutLocked()
+        }
+        if (callback != null && manager != null) {
+            try {
+                manager.unregisterNetworkCallback(callback)
+            } catch (_: IllegalArgumentException) {
+                // Already unregistered by the platform.
+            }
+        }
+        rejectPendingConnect("ERR_LOCAL_WIFI_CANCELLED", "Local WiFi connection cancelled")
+    }
+
+    private fun clearNetworkCallback(callback: ConnectivityManager.NetworkCallback) {
+        val manager = appContext.reactContext?.getSystemService(ConnectivityManager::class.java)
+        synchronized(lock) {
+            if (networkCallback == callback) {
+                networkCallback = null
+                localNetwork = null
+                networkReadiness.clear()
+                cancelReadinessTimeoutLocked()
+            }
+        }
+        if (manager != null) {
+            try {
+                manager.unregisterNetworkCallback(callback)
+            } catch (_: IllegalArgumentException) {
+                // Callback was not registered or has already been removed.
+            }
+        }
+    }
+
+    private fun rejectPendingConnect(code: String, message: String, cause: Throwable? = null) {
+        val promise: Promise?
+        synchronized(lock) {
+            promise = pendingConnectPromise
+            pendingConnectPromise = null
+        }
+        promise?.reject(code, message, cause)
+    }
+}

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

@@ -0,0 +1,88 @@
+package com.glassly.bluetoothsdk
+
+import java.util.UUID
+import org.json.JSONObject
+
+/** Observable state management with immediate event emission */
+class ObservableStore {
+    companion object {
+        const val BLUETOOTH_CATEGORY = "bluetooth"
+        private const val LEGACY_CORE_CATEGORY = "core"
+
+        fun normalizeCategory(category: String): String =
+                if (category == LEGACY_CORE_CATEGORY) BLUETOOTH_CATEGORY else category
+    }
+
+    private val values = mutableMapOf<String, Any>()
+    private val emitListeners = linkedMapOf<String, (String, Map<String, Any>) -> Unit>()
+
+    @Synchronized
+    fun configure(onEmit: (String, Map<String, Any>) -> Unit) {
+        emitListeners["default"] = onEmit
+    }
+
+    @Synchronized
+    fun addListener(onEmit: (String, Map<String, Any>) -> Unit): String {
+        val id = UUID.randomUUID().toString()
+        emitListeners[id] = onEmit
+        return id
+    }
+
+    @Synchronized
+    fun removeListener(id: String) {
+        emitListeners.remove(id)
+    }
+
+    fun set(category: String, key: String, value: Any) {
+        val normalizedCategory: String
+        val listeners: List<(String, Map<String, Any>) -> Unit>
+
+        synchronized(this) {
+            normalizedCategory = normalizeCategory(category)
+            val fullKey = "$normalizedCategory.$key"
+            val oldValue = values[fullKey]
+
+            // Skip if unchanged
+            if (oldValue != null && toJson(oldValue) == toJson(value)) return
+
+            values[fullKey] = value
+            listeners = emitListeners.values.toList()
+        }
+
+        // Emit immediately, outside the store lock so callbacks can safely re-enter the store.
+        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"]
+
+    @Synchronized
+    fun getCategory(category: String): Map<String, Any> {
+        val prefix = "${normalizeCategory(category)}."
+        return values.filterKeys { it.startsWith(prefix) }.mapKeys { it.key.removePrefix(prefix) }
+    }
+
+    private fun toJson(value: Any): String {
+        return JSONObject(mapOf("v" to value)).toString()
+    }
+}

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

@@ -0,0 +1,191 @@
+package com.glassly.bluetoothsdk
+
+import java.net.HttpURLConnection
+import java.net.URI
+import java.net.URL
+import org.json.JSONArray
+import org.json.JSONObject
+
+internal object 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.
+    const val LEGACY_PROD_OTA_VERSION_URL = "https://ota.glassly.ai/prod_live_version.json"
+
+    fun defaultOtaVersionUrl(): String {
+        val manifestUrl = GeneratedReleaseMetadata.OTA_MANIFEST_URL.trim()
+        if (manifestUrl.isBlank()) {
+            throw BluetoothSdkException(
+                "ota_manifest_unconfigured",
+                "This source-built Bluetooth SDK has no embedded OTA manifest. Configure one with the debug API.",
+            )
+        }
+        return manifestUrl
+    }
+}
+
+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 BluetoothSdkException("invalid_ota_url", "OTA version URL must be a non-empty http(s) URL.")
+        }
+
+        val uri =
+            try {
+                URI(trimmed)
+            } catch (error: Exception) {
+                throw BluetoothSdkException("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 BluetoothSdkException("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 BluetoothSdkException("ota_manifest_request_failed", "OTA manifest request failed with HTTP $status for $otaVersionUrl.")
+            }
+            JSONObject(connection.inputStream.bufferedReader().use { it.readText() })
+        } finally {
+            connection.disconnect()
+        }
+    }
+
+    fun hasUpdate(
+        currentBuildNumber: String,
+        currentMtkVersion: String,
+        currentBesVersion: String,
+        manifest: JSONObject,
+        // 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 therefore get upgrade-only behavior and are never told a downgrade is
+        // available that the glasses would refuse.
+        downgradeFloorVersionCode: Long = 0L,
+    ): Boolean =
+        hasApkUpdate(currentBuildNumber, manifest, downgradeFloorVersionCode) ||
+            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 BluetoothSdkException("invalid_ota_manifest", "OTA manifest is missing ASG app versionCode.")
+    }
+
+    private fun hasApkUpdate(
+        currentBuildNumber: String,
+        manifest: JSONObject,
+        downgradeFloorVersionCode: Long,
+    ): Boolean {
+        val currentVersion =
+            currentBuildNumber.toLongOrNull()
+                ?: throw BluetoothSdkException(
+                    "invalid_glasses_version",
+                    "Cannot check OTA update because glasses build number is invalid.",
+                )
+        // 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 — otherwise a build newer than such a manifest would report a false
+        // downgrade the JS path ignores.
+        val isExactPin = manifest.optJSONObject("apps")?.optJSONObject(ASG_CLIENT_PACKAGE)?.hasNumber("versionCode") == true
+        val serverVersion = latestAppInfo(manifest).requiredLong("versionCode")
+        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".
+        if (serverVersion <= 0) {
+            if (currentVersion >= 39) {
+                throw BluetoothSdkException(
+                    "invalid_ota_manifest",
+                    "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 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 BluetoothSdkException("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 BluetoothSdkException("invalid_ota_manifest", "OTA manifest is missing ASG app versionCode.")
+}