@mentra/bluetooth-sdk 3.3.0-dev.822 → 3.3.0-dev.825

package/README.md

@@ -217,9 +217,9 @@ reordering rows just because RSSI metadata arrives later.
 
 ## Mentra SDK Usage Analytics
 
-The SDK sends three usage events to Mentra's PostHog project by default so
-Mentra can understand SDK adoption, successful glasses connections, and
-enterprise device deployments:
+The SDK sends usage events to Mentra's PostHog project by default so Mentra
+can understand SDK adoption, glasses connections, enterprise device
+deployments, and how Mentra Live features are used:
 
 - `bluetooth_sdk_started`: sent once per app runtime after the native SDK starts.
 - `bluetooth_sdk_glasses_connected`: sent when SDK status transitions from not connected to connected.
@@ -229,6 +229,45 @@ The connected event waits for the glasses model when the model is not known at
 the moment the connection flag flips; if the connection ends first it is sent
 without a model and with `glasses_model_unresolved=true`.
 
+Each usage occurrence below is one event, sent when it happens:
+
+- `bluetooth_sdk_glasses_disconnected`: a connection reported as connected
+  ended. Carries `session_duration_ms`, `disconnect_reason` (`user_disconnect`,
+  `forget`, `cancel`, `bluetooth_off`, `link_lost`, or `unknown`), and the
+  battery levels seen during the connection. A connection already up when the
+  SDK started is not reported.
+- `bluetooth_sdk_photo_taken`: a `requestPhoto` call settled, or a photo taken
+  with the glasses button failed (successful button photos never reach the
+  phone). Carries `trigger` (`api` / `button`), `success`, `error_code`,
+  `latency_ms`, the requested size, mode, compression, gallery save and
+  transfer method, and `file_size_bytes` when the response carries it.
+- `bluetooth_sdk_video_recorded`: an app- or button-started recording stopped
+  or failed. Carries `trigger`, `success`, `error_code`, `duration_ms` (phone
+  clock, start to stop status), the requested resolution and frame rate,
+  gallery save, maximum duration, and `stopped_by_app`.
+- `bluetooth_sdk_stream_started` / `bluetooth_sdk_stream_ended`: a
+  `startStream` call settled, and that stream later ended. `protocol` comes
+  from the URL scheme only (`rtmp`, `srt`, `whip`, or `unknown`). The start
+  carries the requested video settings, `capture_audio`, `glasses_network`, and
+  `latency_ms`; the end carries `duration_ms`, `end_state`, `stopped_by_app`,
+  `reconnect_attempts`, `error_code`, and the last bitrate, frame rate, dropped
+  frames, and temperature when the stream reported statistics.
+- `bluetooth_sdk_mic_session`: the active microphone turned off or changed.
+  Carries `duration_ms`, `mic_source`, and `local_transcription`.
+- `bluetooth_sdk_wifi_setup` / `bluetooth_sdk_hotspot_started`:
+  `sendWifiCredentials` or `setHotspotState(true)` settled, with `success`,
+  `error_code`, and `latency_ms`.
+- `bluetooth_sdk_ota_finished`: a glasses software update completed or failed,
+  with the failed step and error, `total_steps`, `duration_ms`, and the
+  glasses versions it started from.
+- `bluetooth_sdk_request_failed`: a glasses command timed out
+  (`error_code=request_timeout`), named by `operation`. At most 100 per SDK
+  start.
+
+These usage events also carry the connected glasses' `glasses_model`,
+`glasses_device_id` and `glasses_build_number` when known. A recording or
+stream whose end never reaches the running app produces only its start.
+
 Analytics delivery never blocks Bluetooth SDK behavior: events are submitted
 asynchronously off the caller thread. An upload that fails (no network, non-2xx)
 is kept in a small on-device queue (at most 100 events, 7 days) and retried on
@@ -281,10 +320,30 @@ write token, not a private PostHog personal API key. Apps do not configure the
 analytics destination; these SDK usage events are always sent to Mentra's
 PostHog project unless analytics are disabled.
 
+### Update check
+
+Separately from analytics, the SDK checks for a newer SDK release every time it
+starts, whether or not analytics are disabled. The check is one HTTPS request
+(4-second timeout, no retry) to
+`https://core.mentraglass.com/api/client/bluetooth-sdk/update-check` carrying
+`install_id` (the same anonymous install id analytics uses), `app_identifier`,
+`app_version`, `app_build`, `app_build_type`, `app_install_source`,
+`app_environment`, `sdk_version`, `sdk_platform`, `sdk_surface`,
+`os_platform`, and `os_version`. Mentra records each check. The SDK compares
+itself with the latest release on its own channel (stable, beta, or dev).
+
+When a newer release exists, the SDK prints a banner with the update command to
+the developer console: Logcat (`MentraBluetoothSDK` tag) on Android, the Xcode
+console on iOS, and `console.warn` in React Native, which shows as a LogBox
+warning in debug builds. The banner repeats every 15 minutes while the SDK
+instance lives. Nothing is shown in app UI. A network that blocks
+`core.mentraglass.com` loses only the banner; SDK behavior is unchanged.
+
 Captured properties include `event_source`, `sdk_platform`, `sdk_surface`,
 `sdk_version`, `app_identifier` (the Android package or iOS bundle identifier),
 the platform-specific `app_package` or `app_bundle_identifier`, OS
-platform/version, and `event_kind`. Every event also carries host build facts:
+platform/version, `phone_manufacturer`, `phone_model`, `locale`, `timezone`,
+and `event_kind`. Every event also carries host build facts:
 `app_version`, `app_build`, `app_build_type` (`debug` / `release`),
 `app_install_source` (`play_store`, `app_store`, `testflight`, `adhoc_or_dev`,
 `simulator`, `sideload`, a named third-party store, `other_store`, or `unknown`
@@ -308,8 +367,11 @@ decode it from the glasses' BLE advertisement / manufacturer data.
 
 Apart from that glasses serial, the SDK does not upload BLE MAC addresses,
 CoreBluetooth identifiers, the host phone's Android device serial, Bluetooth
-device names, user ids, tokens, Wi-Fi credentials, microphone data, photos, or
-transcripts. PostHog receives a locally generated anonymous SDK install id as
+device names, user ids, tokens, Wi-Fi names or credentials, stream, webhook or
+upload URLs, microphone data, photos, videos, or transcripts, and it never reads
+device location. Error details have URLs removed before they are sent. PostHog
+derives an approximate location (country, region, city) from the IP address
+each event is sent from. PostHog receives a locally generated anonymous SDK install id as
 `distinct_id`, and events include `$process_person_profile: false`.
 
 ## React Hooks

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

@@ -46,7 +46,12 @@ internal class BluetoothSdkAnalytics(
     // The tracker is touched from store listeners and SDK entry points, hence
     // @Synchronized on the methods that read or write it.
     private val tracker = BluetoothSdkAnalyticsTracker(DeviceTypes.SIMULATED)
+    private val usage = BluetoothSdkUsageTracker()
     private var startedCaptured = false
+    private var lastGlasses: AnalyticsGlassesSnapshot? = null
+    // Set by an SDK disconnect/forget/cancel call and consumed by the next
+    // connected -> disconnected transition, so that transition can say why.
+    private var pendingDisconnectReason: String? = null
     // Resolved once, lazily, on the transport executor: PackageManager lookups
     // must not run on the caller (often main or the Bluetooth status) thread.
     private val hostProperties: Map<String, Any> by lazy { BluetoothSdkAnalyticsHost.resolve(appContext).toMap() }
@@ -56,9 +61,15 @@ internal class BluetoothSdkAnalytics(
         timeZone = TimeZone.getTimeZone("UTC")
     }
 
+    /** False when the host disabled analytics; callers skip building usage facts entirely. */
+    val isEnabled: Boolean
+        get() = config.isReady
+
     @Synchronized
     fun initializeGlassesStatus(status: GlassesStatus) {
-        tracker.initialize(status.toAnalyticsSnapshot(), BluetoothSdkAnalyticsTracker.reportingDay(System.currentTimeMillis()))
+        val snapshot = status.toAnalyticsSnapshot()
+        lastGlasses = snapshot
+        tracker.initialize(snapshot, BluetoothSdkAnalyticsTracker.reportingDay(System.currentTimeMillis()))
     }
 
     @Synchronized
@@ -71,12 +82,54 @@ internal class BluetoothSdkAnalytics(
     }
 
     @Synchronized
-    fun observeGlassesStatus(status: GlassesStatus) {
-        val events = tracker.observe(status.toAnalyticsSnapshot(), BluetoothSdkAnalyticsTracker.reportingDay(System.currentTimeMillis()))
+    fun observeGlassesStatus(status: GlassesStatus, phoneBluetoothOff: () -> Boolean) {
+        val snapshot = status.toAnalyticsSnapshot()
+        lastGlasses = snapshot
+        val now = System.currentTimeMillis()
+        val events =
+            tracker.observe(snapshot, BluetoothSdkAnalyticsTracker.reportingDay(now), now) {
+                pendingDisconnectReason
+                    ?: if (phoneBluetoothOff()) {
+                        BluetoothSdkAnalyticsTracker.DISCONNECT_BLUETOOTH_OFF
+                    } else {
+                        BluetoothSdkAnalyticsTracker.DISCONNECT_LINK_LOST
+                    }
+            }
+        if (!snapshot.connected || events.any { it.name == "bluetooth_sdk_glasses_connected" }) {
+            pendingDisconnectReason = null
+        }
         if (!config.isReady) return
         for (event in events) capture(event.name, event.properties)
     }
 
+    @Synchronized
+    fun noteDisconnectRequested(reason: String) {
+        if (lastGlasses?.connected == true) pendingDisconnectReason = reason
+    }
+
+    @Synchronized
+    fun recordUsage(build: BluetoothSdkUsageTracker.() -> AnalyticsEvent?) {
+        if (!config.isReady) return
+        val event = usage.build() ?: return
+        capture(event.name, glassesContext() + event.properties)
+    }
+
+    /** Usage-tracker state changes that emit nothing themselves (e.g. a stop request). */
+    @Synchronized
+    fun updateUsage(update: BluetoothSdkUsageTracker.() -> Unit) {
+        if (!config.isReady) return
+        usage.update()
+    }
+
+    private fun glassesContext(): Map<String, Any> {
+        val glasses = lastGlasses?.takeIf { it.connected } ?: return emptyMap()
+        return buildMap {
+            glasses.model.takeIf { it.isNotBlank() }?.let { put("glasses_model", it) }
+            glasses.serialNumber.validManufacturingSerial()?.let { put("glasses_device_id", it) }
+            glasses.buildNumber.takeIf { it.isNotBlank() }?.let { put("glasses_build_number", it) }
+        }
+    }
+
     /**
      * Delivery is owned by the process-wide transport, so nothing is torn down
      * here: a retry in flight when this instance closes still completes, and a
@@ -101,7 +154,7 @@ internal class BluetoothSdkAnalytics(
                         "api_key" to DEFAULT_POSTHOG_API_KEY,
                         "uuid" to uuid,
                         "event" to eventName,
-                        "distinct_id" to distinctId(),
+                        "distinct_id" to BluetoothSdkInstallId.get(appContext),
                         "timestamp" to isoFormat.format(Date(capturedAt)),
                         "properties" to baseProperties(activeConfig) + hostProperties + eventProperties,
                     )
@@ -156,16 +209,12 @@ internal class BluetoothSdkAnalytics(
             put("app_package", appContext.packageName)
             put("os_platform", "android")
             put("os_version", Build.VERSION.SDK_INT)
+            Build.MANUFACTURER?.takeIf { it.isNotBlank() }?.let { put("phone_manufacturer", it) }
+            Build.MODEL?.takeIf { it.isNotBlank() }?.let { put("phone_model", it) }
+            put("locale", Locale.getDefault().toLanguageTag())
+            put("timezone", TimeZone.getDefault().id)
         }
 
-    private fun distinctId(): String {
-        val prefs = appContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-        prefs.getString(PREFS_DISTINCT_ID, null)?.let { return it }
-        val generated = "mentra-bt-sdk-${UUID.randomUUID()}"
-        prefs.edit().putString(PREFS_DISTINCT_ID, generated).apply()
-        return generated
-    }
-
     private fun captureUrl(): String {
         val normalized = DEFAULT_POSTHOG_HOST.trim().trimEnd('/')
         return "$normalized/i/v0/e/"
@@ -173,8 +222,6 @@ internal class BluetoothSdkAnalytics(
 
     companion object {
         internal const val META_ANALYTICS_DISABLED = "com.mentra.bluetoothsdk.analytics.disabled"
-        private const val PREFS_NAME = "mentra_bluetooth_sdk_analytics"
-        private const val PREFS_DISTINCT_ID = "distinct_id"
         private const val DEFAULT_POSTHOG_API_KEY = "phc_FCweXVAxVgU7wZK4Fk3okOx4RmyNqVHJf62YpZSfJt5"
         private const val DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com"
     }
@@ -212,4 +259,6 @@ private fun GlassesStatus.toAnalyticsSnapshot(): AnalyticsGlassesSnapshot =
         androidVersion = androidVersion,
         appVersion = appVersion,
         buildNumber = buildNumber,
+        batteryLevel = batteryLevel,
+        charging = charging,
     )

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

@@ -14,6 +14,9 @@ internal data class AnalyticsGlassesSnapshot(
     val androidVersion: String = "",
     val appVersion: String = "",
     val buildNumber: String = "",
+    /** -1 while the glasses have not reported a level. */
+    val batteryLevel: Int = -1,
+    val charging: Boolean = false,
 )
 
 internal data class AnalyticsEvent(
@@ -36,12 +39,21 @@ internal data class AnalyticsEvent(
  *   is visible in both weeks. Reporting days follow `America/Los_Angeles`, the
  *   calendar the WAU weeks are cut on; a UTC day would miss the Sunday-evening to
  *   Monday-morning Pacific boundary, which is one UTC day.
+ * - `bluetooth_sdk_glasses_disconnected` when a counted connection ends, with its
+ *   length, why it ended, and the battery levels seen during it. The reason is
+ *   supplied by the caller: an SDK disconnect/forget/cancel call, the phone's
+ *   Bluetooth turning off, or otherwise a lost link.
  */
 internal class BluetoothSdkAnalyticsTracker(private val simulatedModel: String) {
     private var lastConnected = false
     private var connectedPendingModel = false
     private var identifiedSerial: String? = null
     private var identifiedReportingDay: Long? = null
+    private var connectedAtMs: Long? = null
+    private var batteryAtConnect = -1
+    private var lastBattery = -1
+    private var lastCharging: Boolean? = null
+    private var lastModel = ""
 
     fun initialize(snapshot: AnalyticsGlassesSnapshot, reportingDay: Long) {
         lastConnected = snapshot.connected
@@ -54,7 +66,12 @@ internal class BluetoothSdkAnalyticsTracker(private val simulatedModel: String)
         identifiedReportingDay = identifiedSerial?.let { reportingDay }
     }
 
-    fun observe(snapshot: AnalyticsGlassesSnapshot, reportingDay: Long): List<AnalyticsEvent> {
+    fun observe(
+        snapshot: AnalyticsGlassesSnapshot,
+        reportingDay: Long,
+        nowMs: Long = 0L,
+        disconnectReason: () -> String = { DISCONNECT_UNKNOWN },
+    ): List<AnalyticsEvent> {
         val events = mutableListOf<AnalyticsEvent>()
         val wasConnected = lastConnected
         lastConnected = snapshot.connected
@@ -64,14 +81,30 @@ internal class BluetoothSdkAnalyticsTracker(private val simulatedModel: String)
                 connectedPendingModel = false
                 events += connectedEvent(snapshot, modelUnresolved = true)
             }
+            connectedAtMs?.let { startedAt ->
+                events += disconnectedEvent(nowMs - startedAt, disconnectReason())
+            }
+            connectedAtMs = null
             identifiedSerial = null
             identifiedReportingDay = null
             return events
         }
 
+        if (snapshot.model.isNotBlank()) lastModel = snapshot.model
+        if (snapshot.batteryLevel >= 0) {
+            if (batteryAtConnect < 0) batteryAtConnect = snapshot.batteryLevel
+            lastBattery = snapshot.batteryLevel
+            lastCharging = snapshot.charging
+        }
+
         if (!wasConnected) {
             identifiedSerial = null
             identifiedReportingDay = null
+            connectedAtMs = nowMs
+            lastModel = snapshot.model
+            batteryAtConnect = snapshot.batteryLevel
+            lastBattery = snapshot.batteryLevel
+            lastCharging = snapshot.charging.takeIf { snapshot.batteryLevel >= 0 }
             if (snapshot.model.isBlank()) {
                 connectedPendingModel = true
             } else {
@@ -106,6 +139,21 @@ internal class BluetoothSdkAnalyticsTracker(private val simulatedModel: String)
             },
         )
 
+    private fun disconnectedEvent(durationMs: Long, reason: String) =
+        AnalyticsEvent(
+            "bluetooth_sdk_glasses_disconnected",
+            buildMap {
+                put("event_kind", "glasses_disconnected")
+                put("session_duration_ms", durationMs.coerceAtLeast(0))
+                put("disconnect_reason", reason)
+                lastModel.takeIf { it.isNotBlank() }?.let { put("glasses_model", it) }
+                put("glasses_is_simulated", lastModel == simulatedModel)
+                batteryAtConnect.takeIf { it >= 0 }?.let { put("battery_level_at_connect", it) }
+                lastBattery.takeIf { it >= 0 }?.let { put("battery_level_at_disconnect", it) }
+                lastCharging?.let { put("charging", it) }
+            },
+        )
+
     private fun identifiedEvent(snapshot: AnalyticsGlassesSnapshot, serial: String, kind: String) =
         AnalyticsEvent(
             "bluetooth_sdk_glasses_identified",
@@ -126,6 +174,12 @@ internal class BluetoothSdkAnalyticsTracker(private val simulatedModel: String)
         )
 
     companion object {
+        const val DISCONNECT_USER = "user_disconnect"
+        const val DISCONNECT_FORGET = "forget"
+        const val DISCONNECT_CANCEL = "cancel"
+        const val DISCONNECT_BLUETOOTH_OFF = "bluetooth_off"
+        const val DISCONNECT_LINK_LOST = "link_lost"
+        const val DISCONNECT_UNKNOWN = "unknown"
         const val MILLIS_PER_DAY = 86_400_000L
         val REPORTING_ZONE: TimeZone = TimeZone.getTimeZone("America/Los_Angeles")
 

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

@@ -0,0 +1,23 @@
+package com.mentra.bluetoothsdk
+
+import android.content.Context
+import java.util.UUID
+
+/**
+ * One random id per app install, shared by usage analytics (as the PostHog
+ * `distinct_id`) and the startup update check, so both describe the same install.
+ * It is created on first use whether or not analytics is enabled.
+ */
+internal object BluetoothSdkInstallId {
+    private const val PREFS_NAME = "mentra_bluetooth_sdk_analytics"
+    private const val PREFS_DISTINCT_ID = "distinct_id"
+
+    @Synchronized
+    fun get(context: Context): String {
+        val prefs = context.applicationContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        prefs.getString(PREFS_DISTINCT_ID, null)?.let { return it }
+        val generated = "mentra-bt-sdk-${UUID.randomUUID()}"
+        prefs.edit().putString(PREFS_DISTINCT_ID, generated).apply()
+        return generated
+    }
+}

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

@@ -334,6 +334,7 @@ class BluetoothSdkModule : Module() {
             "glasses_status",
             "bluetooth_status",
             "log",
+            "sdk_update_notice",
             "device_discovered",
             "default_device_changed",
             // Individual event handlers

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

@@ -0,0 +1,184 @@
+package com.mentra.bluetoothsdk
+
+import android.content.Context
+import android.os.Build
+import org.json.JSONObject
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.concurrent.Executors
+import java.util.concurrent.RejectedExecutionException
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.ScheduledFuture
+import java.util.concurrent.TimeUnit
+
+internal data class BluetoothSdkUpdateCheckResult(
+    val status: String,
+    val channel: String,
+    val latestVersion: String?,
+    val minimumSupportedVersion: String?,
+) {
+    companion object {
+        fun parse(body: String): BluetoothSdkUpdateCheckResult? =
+            try {
+                val json = JSONObject(body)
+                BluetoothSdkUpdateCheckResult(
+                    status = json.optString("status"),
+                    channel = json.optString("channel"),
+                    latestVersion = json.optNonBlankString("latestVersion"),
+                    minimumSupportedVersion = json.optNonBlankString("minimumSupportedVersion"),
+                )
+            } catch (_: Exception) {
+                null
+            }
+
+        private fun JSONObject.optNonBlankString(key: String): String? =
+            if (isNull(key)) null else optString(key).trim().takeIf { it.isNotEmpty() }
+    }
+}
+
+/** The developer-facing console banner for an out-of-date SDK. Never shown in app UI. */
+internal object BluetoothSdkUpdateNotice {
+    const val STATUS_UPDATE_AVAILABLE = "update_available"
+    const val STATUS_UNSUPPORTED = "unsupported"
+    private const val RULE = "=================================================================="
+
+    /** Null when the installed SDK is current or the server could not tell. */
+    fun banner(installedVersion: String, result: BluetoothSdkUpdateCheckResult, surface: String): String? {
+        val latest = result.latestVersion
+        val heading =
+            when (result.status) {
+                STATUS_UNSUPPORTED -> "MENTRA BLUETOOTH SDK $installedVersion IS NO LONGER SUPPORTED"
+                STATUS_UPDATE_AVAILABLE -> if (latest != null) "MENTRA BLUETOOTH SDK UPDATE AVAILABLE" else return null
+                else -> return null
+            }
+        return buildString {
+            appendLine(RULE)
+            appendLine("  $heading")
+            appendLine("  Installed: $installedVersion    Latest: ${latest ?: "unknown"}")
+            appendLine("  Update:    ${updateLine(surface, latest)}")
+            if (result.status == STATUS_UNSUPPORTED) {
+                appendLine("  This version has known issues that are fixed in newer releases.")
+            }
+            appendLine("  Running an old SDK is the most common cause of glasses issues.")
+            append(RULE)
+        }
+    }
+
+    private fun updateLine(surface: String, version: String?): String =
+        when (surface) {
+            "react_native" -> "bun add @mentra/bluetooth-sdk@${version ?: "latest"}"
+            "ios" -> "the MentraBluetoothSDK Swift package at ${version ?: "its latest release"}"
+            else -> "com.mentraglass:bluetooth-sdk:${version ?: "<latest release>"}"
+        }
+}
+
+/**
+ * Checks Mentra Core for a newer SDK on every SDK start and, when this SDK is
+ * behind, prints a console banner now and every [REPRINT_INTERVAL_MINUTES] while
+ * the SDK instance lives. The check is one request with a short timeout and no
+ * retry; any failure is silent and changes no SDK behavior. It runs regardless
+ * of the analytics setting.
+ */
+internal class BluetoothSdkUpdateCheck(
+    context: Context,
+    private val surface: String,
+    private val sdkVersion: String = BuildConfig.SDK_VERSION,
+    private val transport: (String) -> String? = ::post,
+    private val onNotice: (banner: String, result: BluetoothSdkUpdateCheckResult) -> Unit,
+) {
+    private val appContext = context.applicationContext
+    private val lock = Any()
+    private var stopped = false
+    private var reprint: ScheduledFuture<*>? = null
+
+    fun start() {
+        if (!isCheckable(sdkVersion)) return
+        try {
+            executor.execute { runCatching { check() } }
+        } catch (_: RejectedExecutionException) {
+        }
+    }
+
+    fun stop() {
+        synchronized(lock) {
+            stopped = true
+            reprint?.cancel(false)
+            reprint = null
+        }
+    }
+
+    private fun check() {
+        val response = transport(requestBody().toString()) ?: return
+        val result = BluetoothSdkUpdateCheckResult.parse(response) ?: return
+        val banner = BluetoothSdkUpdateNotice.banner(sdkVersion, result, surface) ?: return
+        synchronized(lock) {
+            if (stopped) return
+            onNotice(banner, result)
+            reprint =
+                executor.scheduleAtFixedRate(
+                    { synchronized(lock) { if (!stopped) onNotice(banner, result) } },
+                    REPRINT_INTERVAL_MINUTES,
+                    REPRINT_INTERVAL_MINUTES,
+                    TimeUnit.MINUTES,
+                )
+        }
+    }
+
+    internal fun requestBody(): JSONObject {
+        val host = BluetoothSdkAnalyticsHost.resolve(appContext)
+        return JSONObject().apply {
+            put("install_id", BluetoothSdkInstallId.get(appContext))
+            put("app_identifier", appContext.packageName)
+            host.appVersion?.let { put("app_version", it) }
+            host.appBuild?.let { put("app_build", it) }
+            put("app_build_type", host.buildType)
+            put("app_install_source", host.installSource)
+            host.environment?.let { put("app_environment", it) }
+            put("sdk_version", sdkVersion)
+            put("sdk_platform", "android")
+            put("sdk_surface", surface)
+            put("os_platform", "android")
+            put("os_version", Build.VERSION.SDK_INT.toString())
+        }
+    }
+
+    companion object {
+        const val UPDATE_CHECK_URL = "https://core.mentraglass.com/api/client/bluetooth-sdk/update-check"
+        const val REPRINT_INTERVAL_MINUTES = 15L
+        private const val TIMEOUT_MS = 4_000
+
+        private val executor: ScheduledExecutorService =
+            Executors.newSingleThreadScheduledExecutor { runnable ->
+                Thread(runnable, "MentraBluetoothSdkUpdateCheck").apply { isDaemon = true }
+            }
+
+        fun isCheckable(version: String): Boolean = version.isNotBlank() && version != "unknown"
+
+        private fun post(body: String): String? {
+            val connection = URL(UPDATE_CHECK_URL).openConnection() as HttpURLConnection
+            return try {
+                connection.requestMethod = "POST"
+                connection.connectTimeout = TIMEOUT_MS
+                connection.readTimeout = TIMEOUT_MS
+                connection.doOutput = true
+                connection.setRequestProperty("Content-Type", "application/json")
+                connection.outputStream.use { it.write(body.toByteArray(Charsets.UTF_8)) }
+                if (connection.responseCode != 200) {
+                    connection.errorStream?.close()
+                    null
+                } else {
+                    connection.inputStream.bufferedReader(Charsets.UTF_8).use { it.readText() }
+                }
+            } catch (_: Exception) {
+                null
+            } finally {
+                connection.disconnect()
+            }
+        }
+
+        /** Test hook: waits until every task submitted so far has run. */
+        internal fun awaitIdle() {
+            executor.submit {}.get()
+        }
+    }
+}