@mentra/bluetooth-sdk 3.2.1 → 3.3.0-beta.942

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/LatinTextSanitizer.kt

@@ -0,0 +1,39 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import java.text.Normalizer
+
+private val LATIN_COMBINING_MARKS = Regex("\\p{M}+")
+private val LATIN_LETTERS_WITH_MARKS = Regex("\\p{IsLatin}\\p{M}*")
+
+/** Converts accented and extended Latin letters to base glyphs at the device boundary. */
+internal fun sanitizeLatinDisplayText(text: String, preserveOtherScripts: Boolean = false): String {
+    val expanded = buildString(text.length) {
+        text.forEach { character ->
+            when (character) {
+                'Đ', 'Ð' -> append('D')
+                'đ', 'ð' -> append('d')
+                'Ł' -> append('L')
+                'ł' -> append('l')
+                'Ø' -> append('O')
+                'ø' -> append('o')
+                'Æ' -> append("AE")
+                'æ' -> append("ae")
+                'Œ' -> append("OE")
+                'œ' -> append("oe")
+                'ẞ' -> append("SS")
+                'ß' -> append("ss")
+                'Þ' -> append("TH")
+                'þ' -> append("th")
+                else -> append(character)
+            }
+        }
+    }
+
+    if (preserveOtherScripts) {
+        return LATIN_LETTERS_WITH_MARKS.replace(expanded) { match ->
+            Normalizer.normalize(match.value, Normalizer.Form.NFD).replace(LATIN_COMBINING_MARKS, "")
+        }
+    }
+    return Normalizer.normalize(expanded, Normalizer.Form.NFD)
+        .replace(LATIN_COMBINING_MARKS, "")
+}

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/MentraLive.kt

@@ -34,6 +34,7 @@ import android.os.SystemClock
 import com.mentra.bluetoothsdk.utils.NativeLog as Log
 import androidx.core.app.ActivityCompat
 import com.mentra.bluetoothsdk.BluetoothSdkDefaults
+import com.mentra.bluetoothsdk.BluetoothSdkException
 import com.mentra.bluetoothsdk.Bridge
 import com.mentra.bluetoothsdk.DeviceManager
 import com.mentra.bluetoothsdk.PhotoRequest
@@ -645,6 +646,10 @@ class MentraLive : SGCManager() {
     private var a2dpProfile: BluetoothA2dp? = null
     private var isA2dpProxyRegistered = false
     private var a2dpConnectAttempts = 0
+    private val classicAudioServiceDiscovery =
+            ClassicAudioServiceDiscovery(handler, CONNECTION_TIMEOUT_MS.toLong()) {
+                Bridge.log("LIVE: Classic: $it")
+            }
 
     private data class OutgoingBleCommandTraceInfo(
             val commandType: String,
@@ -1708,6 +1713,7 @@ class MentraLive : SGCManager() {
         readinessCompletedThisBleSession = false
         glassesReadyReceived = false
         ctkdInitiatedThisGattSession = false
+        classicAudioServiceDiscovery.cancel()
         audioConnected = false
         notificationsEnabled = false
         currentMtu = 23
@@ -1983,6 +1989,7 @@ class MentraLive : SGCManager() {
         readinessCompletedThisBleSession = false
         glassesReadyReceived = false
         ctkdInitiatedThisGattSession = false
+        classicAudioServiceDiscovery.cancel()
         audioConnected = false
         notificationsEnabled = false
         processSendQueueRunnable?.let { handler.removeCallbacks(it) }
@@ -2350,6 +2357,7 @@ class MentraLive : SGCManager() {
                             registerBondingReceiver()
                             bondingRetryCount = 0
                             ctkdInitiatedThisGattSession = false
+                            classicAudioServiceDiscovery.cancel()
                             Bridge.log(
                                     "LIVE: CTKD: BLE GATT up - deferring Classic/A2DP until notifications ready"
                             )
@@ -2398,6 +2406,7 @@ class MentraLive : SGCManager() {
                             // Reset audio pairing flags
                             glassesReadyReceived = false
                             ctkdInitiatedThisGattSession = false
+                            classicAudioServiceDiscovery.cancel()
                             audioConnected = false
 
                             notificationsEnabled = false
@@ -2460,6 +2469,7 @@ class MentraLive : SGCManager() {
                         glassesReadyReceived = false
                         audioConnected = false
                         ctkdInitiatedThisGattSession = false
+                        classicAudioServiceDiscovery.cancel()
 
                         notificationsEnabled = false
 
@@ -3371,10 +3381,12 @@ class MentraLive : SGCManager() {
         sendJson(json, wakeup, true)
     }
 
-    private fun sendJson(json: JSONObject?, wakeup: Boolean, bridgeLogging: Boolean): Boolean {
+    private fun sendJson(
+            json: JSONObject?, wakeup: Boolean, bridgeLogging: Boolean,
+            sessionGeneration: Long = bleSessionGeneration.get(),
+    ): Boolean {
         if (json != null) {
             try {
-                val sessionGeneration = bleSessionGeneration.get()
                 if (buildNumberInt < 5) {
                     val jsonStr = json.toString()
                     // Bridge.log("LIVE: 📤 Sending JSON with esoteric message ID: " + jsonStr);
@@ -6075,6 +6087,17 @@ class MentraLive : SGCManager() {
     }
 
     override fun sendIncidentId(incidentId: String, apiBaseUrl: String?) {
+        if (!isConnected || bluetoothGatt == null || txCharacteristic == null) {
+            throw BluetoothSdkException(
+                "glasses_not_connected", "Cannot request incident logs because the glasses BLE link is not ready.",
+            )
+        }
+        // The JS token sync may happen after glasses_ready. Use only its current native store value.
+        val coreToken = DeviceStore.get("bluetooth", "core_token") as? String
+        if (coreToken.isNullOrBlank()) {
+            throw BluetoothSdkException("core_token_unavailable", "Cannot request incident logs without the current Core access token.")
+        }
+        val sessionGeneration = bleSessionGeneration.get()
         try {
             var base = if (apiBaseUrl != null) apiBaseUrl.trim() else ""
             if (base.isEmpty()) {
@@ -6087,13 +6110,25 @@ class MentraLive : SGCManager() {
             bleIncidentLogRelays[lKey] =
                     BleIncidentLogRelay(lKey, incidentId, base, BleIncidentLogKind.LOGCAT)
 
+            val auth = JSONObject()
+            auth.put("type", "auth_token")
+            auth.put("coreToken", coreToken)
+            auth.put("timestamp", System.currentTimeMillis())
             val json = JSONObject()
             json.put("type", "upload_incident_logs")
             json.put("incidentId", incidentId)
             json.put("apiBaseUrl", base)
-            sendJson(json, true)
+            // Wake ASG with its current token before the upload command enters the same FIFO.
+            if (!sendJson(auth, true, true, sessionGeneration) ||
+                    sessionGeneration != bleSessionGeneration.get() ||
+                    !isConnected || bluetoothGatt == null || txCharacteristic == null ||
+                    !sendJson(json, true, true, sessionGeneration) || sessionGeneration != bleSessionGeneration.get()) {
+                bleIncidentLogRelays.remove(bKey)
+                bleIncidentLogRelays.remove(lKey)
+                throw BluetoothSdkException("incident_dispatch_failed", "Could not queue the glasses incident-log request.")
+            }
             Bridge.log(
-                    "LIVE: Sent incidentId to glasses for log upload: " +
+                    "LIVE: Queued incidentId to glasses for log upload: " +
                             incidentId +
                             " (BLE relay keys " +
                             bKey +
@@ -6102,7 +6137,7 @@ class MentraLive : SGCManager() {
                             ")"
             )
         } catch (e: JSONException) {
-            Log.e(TAG, "Error creating upload_incident_logs command", e)
+            throw BluetoothSdkException("incident_dispatch_failed", "Could not create the glasses incident-log request.", e)
         }
     }
 
@@ -7208,7 +7243,7 @@ class MentraLive : SGCManager() {
                                     BluetoothDevice.BOND_BONDED ->
                                             run {
                                                 Bridge.log(
-                                                        "LIVE: CTKD: ✅ Successfully bonded with device - BT Classic connection established"
+                                                        "LIVE: CTKD: Successfully bonded - checking Classic audio services"
                                                 )
                                                 markPairingTiming(
                                                         "ctkd_bonded",
@@ -7227,7 +7262,7 @@ class MentraLive : SGCManager() {
                                                 // path does this at GATT connect).
                                                 // markAudioConnected / sendAudioConnected fire
                                                 // when the A2DP path completes.
-                                                connectA2dpProfile(device)
+                                                prepareClassicAudio(device)
 
                                                 // Safety net: if glasses_ready somehow missed
                                                 // setting fullyBooted, catch up here.
@@ -7264,6 +7299,7 @@ class MentraLive : SGCManager() {
                                                 }
                                             }
                                     BluetoothDevice.BOND_NONE -> {
+                                        classicAudioServiceDiscovery.cancel()
                                         Bridge.log(
                                                 "LIVE: CTKD: ❌ Bonding failed or removed for device"
                                         )
@@ -7385,6 +7421,10 @@ class MentraLive : SGCManager() {
         classicAudioReceiver =
                 object : BroadcastReceiver() {
                     override fun onReceive(context: Context?, intent: Intent?) {
+                        if (intent?.action == BluetoothDevice.ACTION_UUID) {
+                            intent.bluetoothDeviceExtra()?.let { classicAudioServiceDiscovery.onUuids(it) }
+                            return
+                        }
                         if (intent?.action != BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED &&
                                 intent?.action != BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED) return
                         val device = intent.bluetoothDeviceExtra() ?: return
@@ -7401,6 +7441,7 @@ class MentraLive : SGCManager() {
         try {
             val filter =
                     IntentFilter().apply {
+                        addAction(BluetoothDevice.ACTION_UUID)
                         addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED)
                         addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED)
                     }
@@ -7525,10 +7566,10 @@ class MentraLive : SGCManager() {
         when (device.bondState) {
             BluetoothDevice.BOND_BONDED -> {
                 Bridge.log(
-                        "LIVE: CTKD: Device is already bonded - connecting A2DP audio profile"
+                        "LIVE: CTKD: Device is already bonded - checking Classic audio services"
                 )
                 markPairingTiming("ctkd_already_bonded")
-                connectA2dpProfile(device)
+                prepareClassicAudio(device)
             }
             BluetoothDevice.BOND_BONDING -> {
                 // Secure pairing firmware may request SMP as soon as GATT connects.
@@ -7587,6 +7628,19 @@ class MentraLive : SGCManager() {
         return classicAudioConnectionTracker.connected
     }
 
+    private fun prepareClassicAudio(device: BluetoothDevice) {
+        if (!canConnectClassicAudio(device)) return
+        val gatt = bluetoothGatt
+        classicAudioServiceDiscovery.connectWhenDiscovered(device) {
+            if (bluetoothGatt === gatt && canConnectClassicAudio(device)) connectA2dpProfile(device)
+        }
+    }
+
+    private fun canConnectClassicAudio(device: BluetoothDevice): Boolean =
+            !isKilled && !pairingYieldActive && isConnected && notificationsEnabled &&
+                    ctkdInitiatedThisGattSession && connectedDevice?.address == device.address &&
+                    device.bondState == BluetoothDevice.BOND_BONDED
+
     /** A2DP profile service listener for connecting to already-bonded devices */
     private val a2dpServiceListener: BluetoothProfile.ServiceListener =
             object : BluetoothProfile.ServiceListener {
@@ -7635,7 +7689,9 @@ class MentraLive : SGCManager() {
             Bridge.log("LIVE: A2DP: Skipping connectA2dpWithProxy — SGC destroyed")
             return
         }
-        if (a2dpProfile == null || device == null) {
+        if (device == null || !canConnectClassicAudio(device) ||
+                !ClassicAudioServiceDiscovery.hasAudioSink(device)) return
+        if (a2dpProfile == null) {
             Bridge.log("LIVE: A2DP: Cannot connect - proxy or device is null")
             return
         }
@@ -7685,14 +7741,11 @@ class MentraLive : SGCManager() {
                 "LIVE: A2DP: Retry $a2dpConnectAttempts/$A2DP_CONNECT_MAX_ATTEMPTS in " +
                         "${A2DP_CONNECT_RETRY_MS}ms ($reason)"
         )
+        val gatt = bluetoothGatt
         handler.postDelayed(
                 Runnable {
-                    if (isKilled || pairingYieldActive || connectedDevice == null) {
-                        return@Runnable
-                    }
-                    val target = connectedDevice ?: return@Runnable
-                    if (a2dpProfile != null) {
-                        connectA2dpWithProxy(target)
+                    if (bluetoothGatt === gatt && canConnectClassicAudio(device)) {
+                        connectA2dpWithProxy(device)
                     }
                 },
                 A2DP_CONNECT_RETRY_MS
@@ -7912,6 +7965,7 @@ class MentraLive : SGCManager() {
 
         // Mark as killed to prevent reconnection attempts
         isKilled = true
+        classicAudioServiceDiscovery.cancel()
         explicitConnectByName = false
         pairingYieldActive = false
         pairingYieldAwaitingReclaim = false
@@ -7933,7 +7987,11 @@ class MentraLive : SGCManager() {
 
         // Tear down Classic (A2DP/HFP) before GATT close. Closing only the proxy left the
         // phone's system Bluetooth UI showing Mentra Live still connected.
-        val classicDevice = connectedDevice
+        // BLE loss clears connectedDevice while the OS audio profiles can remain connected.
+        // Use this session's existing Classic target before resetting the tracker below.
+        val classicDevice = connectedDevice ?: classicAudioConnectionTracker.targetForDisconnect()?.let {
+            bluetoothAdapter?.getRemoteDevice(it)
+        }
         disconnectClassicProfiles(classicDevice)
         closeA2dpProxy()
         classicAudioConnectionTracker.reset()
@@ -8010,6 +8068,7 @@ class MentraLive : SGCManager() {
         glassesReadyReceived = false
         audioConnected = false
         ctkdInitiatedThisGattSession = false
+        classicAudioServiceDiscovery.cancel()
         DeviceStore.apply("glasses", "fullyBooted", false)
         updateConnectionState(ConnTypes.DISCONNECTED)
 
@@ -9497,7 +9556,11 @@ class MentraLive : SGCManager() {
                 }
             } else {
                 // Normal single message transmission
-                transportLog("LIVE: Sending data to glasses: " + wireData, bridgeLogging)
+                transportLog(
+                        "LIVE: Sending data to glasses: " +
+                                loggableOutgoingPayload(wireData, commandTraceInfo.commandType),
+                        bridgeLogging
+                )
 
                 // Pack the data using the centralized utility with the negotiated endianness
                 val packedData =
@@ -9799,6 +9862,18 @@ class MentraLive : SGCManager() {
         }
     }
 
+    /**
+     * Credentials are sent unchanged but never logged; the BLE trace redacts their fields.
+     */
+    private fun loggableOutgoingPayload(payload: String, commandType: String): String =
+            try {
+                val json = JSONObject(payload)
+                if (json.has("password") || json.has("coreToken")) "<$commandType with credentials omitted>"
+                else payload
+            } catch (_: JSONException) {
+                payload
+            }
+
     private fun summarizeOutgoingMessage(payload: String?): String {
         if (payload == null || payload.isEmpty()) {
             return "type=unknown, requestId=none, appId=none, mode=none, transferMethod=none, bleImgId=none, exposureTimeNs=none, iso=none, mId=none"

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/NimoCanvasCodec.kt

@@ -103,7 +103,9 @@ internal object NimoCanvasCodec {
     require(text.length <= 2048 && '\u0000' !in text)
     val encoder = Charsets.UTF_8.newEncoder().onMalformedInput(CodingErrorAction.REPORT)
       .onUnmappableCharacter(CodingErrorAction.REPORT)
-    val encoded = encoder.encode(CharBuffer.wrap(text))
+    // Apply the shared Latin fallback and NIMO's dash fix before counting wire bytes.
+    val displayText = sanitizeLatinDisplayText(text, preserveOtherScripts = true).replace('\u2014', '-')
+    val encoded = encoder.encode(CharBuffer.wrap(displayText))
     val utf8 = ByteArray(encoded.remaining()).also { encoded.get(it) }
     require(utf8.size in 1..2048) { "Label exceeds 2048 UTF-8 bytes" }
     return Object(3, words(x, y, width, height, language) + bytes(font, intensity) + words(utf8.size) + utf8,

package/android/src/test/java/com/mentra/bluetoothsdk/BluetoothSdkAnalyticsTrackerTest.kt

@@ -12,7 +12,61 @@ class BluetoothSdkAnalyticsTrackerTest {
         model: String = "Mentra Live",
         serial: String = "",
         fullyBooted: Boolean = connected,
-    ) = AnalyticsGlassesSnapshot(connected = connected, fullyBooted = fullyBooted, model = model, serialNumber = serial)
+        battery: Int = -1,
+        charging: Boolean = false,
+    ) = AnalyticsGlassesSnapshot(
+        connected = connected,
+        fullyBooted = fullyBooted,
+        model = model,
+        serialNumber = serial,
+        batteryLevel = battery,
+        charging = charging,
+    )
+
+    @Test
+    fun `a counted connection reports its length, reason and battery when it ends`() {
+        tracker.initialize(snapshot(connected = false), reportingDay = 100)
+        tracker.observe(snapshot(connected = true), reportingDay = 100, nowMs = 1_000)
+        tracker.observe(snapshot(connected = true, battery = 80), reportingDay = 100, nowMs = 2_000)
+        tracker.observe(snapshot(connected = true, battery = 71, charging = true), reportingDay = 100, nowMs = 3_000)
+
+        val ended =
+            tracker.observe(snapshot(connected = false), reportingDay = 100, nowMs = 61_000) {
+                BluetoothSdkAnalyticsTracker.DISCONNECT_USER
+            }
+        val disconnected = ended.single()
+        assertThat(disconnected.name).isEqualTo("bluetooth_sdk_glasses_disconnected")
+        assertThat(disconnected.properties)
+            .containsEntry("session_duration_ms", 60_000L)
+            .containsEntry("disconnect_reason", "user_disconnect")
+            .containsEntry("battery_level_at_connect", 80)
+            .containsEntry("battery_level_at_disconnect", 71)
+            .containsEntry("charging", true)
+            .containsEntry("glasses_model", "Mentra Live")
+
+        // Further disconnected updates do not report the connection again.
+        assertThat(tracker.observe(snapshot(connected = false), reportingDay = 100, nowMs = 62_000)).isEmpty()
+    }
+
+    @Test
+    fun `a connection already up when the SDK started is not reported as ending`() {
+        tracker.initialize(snapshot(connected = true, serial = "MLAB0001"), reportingDay = 100)
+        assertThat(tracker.observe(snapshot(connected = false), reportingDay = 100, nowMs = 5_000)).isEmpty()
+    }
+
+    @Test
+    fun `battery from a previous connection does not leak into the next one`() {
+        tracker.initialize(snapshot(connected = false), reportingDay = 100)
+        tracker.observe(snapshot(connected = true, battery = 90), reportingDay = 100, nowMs = 0)
+        tracker.observe(snapshot(connected = false), reportingDay = 100, nowMs = 1_000)
+        tracker.observe(snapshot(connected = true), reportingDay = 100, nowMs = 2_000)
+        val second = tracker.observe(snapshot(connected = false), reportingDay = 100, nowMs = 3_000).single()
+        assertThat(second.properties)
+            .doesNotContainKey("battery_level_at_connect")
+            .doesNotContainKey("battery_level_at_disconnect")
+            .doesNotContainKey("charging")
+            .containsEntry("disconnect_reason", "unknown")
+    }
 
     @Test
     fun `connect then serial emits connected and identified once, reconnects do not repeat identification within a connection`() {
@@ -55,8 +109,9 @@ class BluetoothSdkAnalyticsTrackerTest {
         tracker.initialize(snapshot(connected = false), reportingDay = 100)
         tracker.observe(snapshot(connected = true, model = ""), reportingDay = 100)
         val ended = tracker.observe(snapshot(connected = false, model = ""), reportingDay = 100)
-        assertThat(ended.single().name).isEqualTo("bluetooth_sdk_glasses_connected")
-        assertThat(ended.single().properties).containsEntry("glasses_model_unresolved", true).doesNotContainKey("glasses_model")
+        assertThat(ended.map { it.name })
+            .containsExactly("bluetooth_sdk_glasses_connected", "bluetooth_sdk_glasses_disconnected")
+        assertThat(ended.first().properties).containsEntry("glasses_model_unresolved", true).doesNotContainKey("glasses_model")
     }
 
     @Test

package/android/src/test/java/com/mentra/bluetoothsdk/BluetoothSdkUpdateCheckTest.kt

@@ -0,0 +1,124 @@
+package com.mentra.bluetoothsdk
+
+import androidx.test.core.app.ApplicationProvider
+import android.content.Context
+import org.assertj.core.api.Assertions.assertThat
+import org.json.JSONObject
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class BluetoothSdkUpdateCheckTest {
+    private val context: Context = ApplicationProvider.getApplicationContext()
+
+    private fun result(status: String, latest: String? = "3.2.1", minimum: String? = null) =
+        BluetoothSdkUpdateCheckResult(status, "latest", latest, minimum)
+
+    @Test
+    fun `parses the Core response, treating null and blank versions as unknown`() {
+        val parsed =
+            BluetoothSdkUpdateCheckResult.parse(
+                """{"status":"update_available","channel":"dev","latestVersion":"3.3.0-dev.821","minimumSupportedVersion":null}""",
+            )!!
+        assertThat(parsed).isEqualTo(BluetoothSdkUpdateCheckResult("update_available", "dev", "3.3.0-dev.821", null))
+        assertThat(BluetoothSdkUpdateCheckResult.parse("""{"status":"current","latestVersion":""}""")!!.latestVersion).isNull()
+        assertThat(BluetoothSdkUpdateCheckResult.parse("<html>502</html>")).isNull()
+    }
+
+    @Test
+    fun `the banner names the installed and latest versions and the surface's update command`() {
+        val reactNative = BluetoothSdkUpdateNotice.banner("3.1.0", result("update_available"), "react_native")!!
+        assertThat(reactNative)
+            .contains("MENTRA BLUETOOTH SDK UPDATE AVAILABLE")
+            .contains("Installed: 3.1.0")
+            .contains("Latest: 3.2.1")
+            .contains("bun add @mentra/bluetooth-sdk@3.2.1")
+            .doesNotContain("NO LONGER SUPPORTED")
+        assertThat(BluetoothSdkUpdateNotice.banner("3.1.0", result("update_available"), "android")!!)
+            .contains("com.mentraglass:bluetooth-sdk:3.2.1")
+        assertThat(BluetoothSdkUpdateNotice.banner("3.1.0", result("update_available"), "ios")!!)
+            .contains("MentraBluetoothSDK Swift package at 3.2.1")
+    }
+
+    @Test
+    fun `an unsupported version gets the stronger banner`() {
+        val banner = BluetoothSdkUpdateNotice.banner("3.0.5", result("unsupported", minimum = "3.1.0"), "android")!!
+        assertThat(banner)
+            .contains("MENTRA BLUETOOTH SDK 3.0.5 IS NO LONGER SUPPORTED")
+            .contains("known issues")
+    }
+
+    @Test
+    fun `no banner when current, unknown, or no latest version to point at`() {
+        assertThat(BluetoothSdkUpdateNotice.banner("3.2.1", result("current"), "android")).isNull()
+        assertThat(BluetoothSdkUpdateNotice.banner("3.2.1", result("unknown", latest = null), "android")).isNull()
+        assertThat(BluetoothSdkUpdateNotice.banner("3.2.1", result("update_available", latest = null), "android")).isNull()
+    }
+
+    @Test
+    fun `the request identifies the install, app and SDK`() {
+        val body = BluetoothSdkUpdateCheck(context, "react_native", sdkVersion = "3.1.0", transport = { null }) { _, _ -> }.requestBody()
+        assertThat(body.getString("install_id")).isEqualTo(BluetoothSdkInstallId.get(context)).startsWith("mentra-bt-sdk-")
+        assertThat(body.getString("app_identifier")).isEqualTo(context.packageName)
+        assertThat(body.getString("sdk_version")).isEqualTo("3.1.0")
+        assertThat(body.getString("sdk_platform")).isEqualTo("android")
+        assertThat(body.getString("sdk_surface")).isEqualTo("react_native")
+        assertThat(body.has("app_build_type")).isTrue()
+    }
+
+    @Test
+    fun `an out-of-date SDK prints the banner once at start and stops on close`() {
+        val notices = mutableListOf<String>()
+        var sentBody: String? = null
+        val check =
+            BluetoothSdkUpdateCheck(
+                context,
+                "android",
+                sdkVersion = "3.1.0",
+                transport = { body ->
+                    sentBody = body
+                    """{"status":"update_available","channel":"latest","latestVersion":"3.2.1","minimumSupportedVersion":null}"""
+                },
+            ) { banner, _ -> notices += banner }
+        check.start()
+        BluetoothSdkUpdateCheck.awaitIdle()
+        assertThat(notices).hasSize(1)
+        assertThat(notices.single()).contains("Latest: 3.2.1")
+        assertThat(JSONObject(sentBody!!).getString("sdk_version")).isEqualTo("3.1.0")
+        check.stop()
+    }
+
+    @Test
+    fun `failures and unknown versions are silent`() {
+        val notices = mutableListOf<String>()
+        BluetoothSdkUpdateCheck(context, "android", sdkVersion = "3.1.0", transport = { null }) { banner, _ -> notices += banner }.start()
+        BluetoothSdkUpdateCheck(context, "android", sdkVersion = "3.1.0", transport = { throw IllegalStateException("offline") }) { banner, _ -> notices += banner }.start()
+        var called = false
+        BluetoothSdkUpdateCheck(context, "android", sdkVersion = "unknown", transport = { called = true; null }) { banner, _ -> notices += banner }.start()
+        BluetoothSdkUpdateCheck.awaitIdle()
+        assertThat(notices).isEmpty()
+        assertThat(called).isFalse()
+    }
+
+    @Test
+    fun `a check stopped before the response arrives prints nothing`() {
+        val notices = mutableListOf<String>()
+        lateinit var check: BluetoothSdkUpdateCheck
+        check =
+            BluetoothSdkUpdateCheck(
+                context,
+                "android",
+                sdkVersion = "3.1.0",
+                transport = {
+                    check.stop()
+                    """{"status":"update_available","latestVersion":"3.2.1"}"""
+                },
+            ) { banner, _ -> notices += banner }
+        check.start()
+        BluetoothSdkUpdateCheck.awaitIdle()
+        assertThat(notices).isEmpty()
+    }
+}