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

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

@@ -8,6 +8,7 @@ import android.content.Context
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
+import android.util.Log
 import com.mentra.bluetoothsdk.streaming.StreamSessionState
 import com.mentra.bluetoothsdk.utils.ControllerTypes
 import com.mentra.bluetoothsdk.utils.PhoneAudioMonitor
@@ -34,6 +35,21 @@ class MentraBluetoothSdk private constructor(
     private val listeners =
         Collections.synchronizedSet(mutableSetOf<MentraBluetoothSdkListener>())
     private val analytics = BluetoothSdkAnalytics(appContext, config.analytics)
+    private val updateCheck =
+        BluetoothSdkUpdateCheck(appContext, config.analytics.surface) { banner, result ->
+            Log.w(UPDATE_LOG_TAG, banner)
+            dispatchToListeners {
+                it.onRawEvent(
+                    "sdk_update_notice",
+                    buildMap {
+                        put("message", banner)
+                        put("status", result.status)
+                        put("installedVersion", BuildConfig.SDK_VERSION)
+                        result.latestVersion?.let { latest -> put("latestVersion", latest) }
+                    },
+                )
+            }
+        }
     private val discoveredDeviceNames = mutableSetOf<String>()
     private val bridgeEventSinkId: String
     private val storeListenerId: String
@@ -99,6 +115,7 @@ class MentraBluetoothSdk private constructor(
         analytics.initializeGlassesStatus(getRawGlassesStatus())
         storeListenerId = DeviceStore.store.addListener { category, changes -> dispatchStoreUpdate(category, changes) }
         analytics.captureStarted()
+        updateCheck.start()
     }
 
     companion object {
@@ -106,6 +123,8 @@ class MentraBluetoothSdk private constructor(
         private val SCAN_STATE_KEYS = setOf("searching", "searchingController", "searchResults")
         private const val DEFAULT_SCAN_TIMEOUT_MS = 15_000L
         private const val DEFAULT_REQUEST_TIMEOUT_MS = 15_000L
+        private const val UPDATE_LOG_TAG = "MentraBluetoothSDK"
+        private val MIC_STATE_KEYS = setOf("currentMic", "should_send_transcript", "local_stt_fallback_active")
         // Mirrors AsgConstants: one active + one coalesced pending FOV update, plus BLE margin.
         // Keep in sync with ios/Source/MentraBluetoothSDK.swift and the ASG readiness budget.
         private const val CAMERA_FOV_READY_TIMEOUT_MS = 20_000L
@@ -240,8 +259,10 @@ class MentraBluetoothSdk private constructor(
     // (expo.modules.AsyncFunctionQueue), so a blocked await here froze all
     // miniapp event delivery (Crust.mentraJsDispatchToJs) until the glasses
     // responded. resolve()/reject() stay callable from any thread.
-    private class PendingResponse<T>(
+    private inner class PendingResponse<T>(
         private val operation: String,
+        // The operation without per-request ids, so timeouts group in analytics.
+        private val telemetryOperation: String = operation,
     ) {
         private val deferred = CompletableDeferred<T>()
 
@@ -258,10 +279,13 @@ class MentraBluetoothSdk private constructor(
             // can only mean the deadline elapsed. A rejected deferred rethrows
             // its error from await() and propagates out unchanged.
             return withTimeoutOrNull(timeoutMs) { deferred.await() }
-                ?: throw BluetoothSdkException(
-                    "request_timeout",
-                    "$operation timed out waiting for glasses response.",
-                )
+                ?: run {
+                    analytics.recordUsage { requestTimedOut(telemetryOperation) }
+                    throw BluetoothSdkException(
+                        "request_timeout",
+                        "$operation timed out waiting for glasses response.",
+                    )
+                }
         }
 
     }
@@ -503,6 +527,7 @@ class MentraBluetoothSdk private constructor(
     }
 
     fun cancelConnectionAttempt() {
+        analytics.noteDisconnectRequested(BluetoothSdkAnalyticsTracker.DISCONNECT_CANCEL)
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_name", "")
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_address", "")
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_secure_pairing_capable", "")
@@ -514,6 +539,7 @@ class MentraBluetoothSdk private constructor(
     }
 
     fun disconnect() {
+        analytics.noteDisconnectRequested(BluetoothSdkAnalyticsTracker.DISCONNECT_USER)
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_name", "")
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_address", "")
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "pending_device_secure_pairing_capable", "")
@@ -521,6 +547,7 @@ class MentraBluetoothSdk private constructor(
     }
 
     fun forget() {
+        analytics.noteDisconnectRequested(BluetoothSdkAnalyticsTracker.DISCONNECT_FORGET)
         deviceManager.forget()
     }
 
@@ -651,6 +678,10 @@ class MentraBluetoothSdk private constructor(
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "loudness_gate_enabled", enabled)
     }
 
+    fun setAutoPowerOffEnabled(enabled: Boolean) {
+        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "auto_power_off_enabled", enabled)
+    }
+
     @Deprecated(
         message =
             "Sticky action-button photo presets are deprecated. Prefer per-request " +
@@ -943,8 +974,12 @@ class MentraBluetoothSdk private constructor(
             pendingWifiStatus = PendingWifiStatusRequest(ssid, pending)
         }
         try {
-            deviceManager.sendWifiCredentials(ssid, password)
-            return pending.await()
+            return withUsageOutcome(
+                { latencyMs, errorCode, _ -> analytics.recordUsage { wifiSetupSettled(latencyMs, errorCode) } },
+            ) {
+                deviceManager.sendWifiCredentials(ssid, password)
+                pending.await()
+            }
         } finally {
             synchronized(oneShotLock) {
                 if (pendingWifiStatus?.pending === pending) {
@@ -1058,8 +1093,14 @@ class MentraBluetoothSdk private constructor(
                 pendingHotspotStatus = PendingHotspotStatusRequest(enabled, pending)
             }
             try {
-                deviceManager.setHotspotState(enabled)
-                pending.await()
+                withUsageOutcome(
+                    { latencyMs, errorCode, _ ->
+                        if (enabled) analytics.recordUsage { hotspotStartSettled(latencyMs, errorCode) }
+                    },
+                ) {
+                    deviceManager.setHotspotState(enabled)
+                    pending.await()
+                }
             } finally {
                 synchronized(oneShotLock) {
                     if (pendingHotspotStatus?.pending === pending) {
@@ -1086,13 +1127,31 @@ class MentraBluetoothSdk private constructor(
         Bridge.log(
             "NATIVE: PHOTO PIPELINE [3b/6] MentraBluetoothSdk.requestPhoto requestId=${routedRequest.requestId}"
         )
-        val pending = PendingResponse<PhotoResponseEvent>("photo request ${routedRequest.requestId}")
+        val pending = PendingResponse<PhotoResponseEvent>("photo request ${routedRequest.requestId}", "photo request")
         pendingPhotoRequests[routedRequest.requestId] = pending
         try {
-            deviceManager.requestPhoto(routedRequest)
-            return pending.await(
-                if (routedRequest.presendThumbnail) PHOTO_THUMBNAIL_REQUEST_TIMEOUT_MS else PHOTO_REQUEST_TIMEOUT_MS,
-            )
+            return withUsageOutcome(
+                { latencyMs, errorCode, event ->
+                    val fileSizeBytes = (event?.response as? PhotoResponse.Success)?.fileSizeBytes
+                    analytics.recordUsage {
+                        photoSettled(
+                            size = routedRequest.size.value,
+                            mode = routedRequest.mode.value,
+                            compress = routedRequest.compress.value,
+                            save = routedRequest.save,
+                            transferMethod = routedRequest.transferMethod,
+                            latencyMs = latencyMs,
+                            fileSizeBytes = fileSizeBytes,
+                            errorCode = errorCode,
+                        )
+                    }
+                },
+            ) {
+                deviceManager.requestPhoto(routedRequest)
+                pending.await(
+                    if (routedRequest.presendThumbnail) PHOTO_THUMBNAIL_REQUEST_TIMEOUT_MS else PHOTO_REQUEST_TIMEOUT_MS,
+                )
+            }
         } finally {
             pendingPhotoRequests.remove(routedRequest.requestId, pending)
         }
@@ -1108,7 +1167,7 @@ class MentraBluetoothSdk private constructor(
         mfnr: Boolean? = null,
     ): CameraStatusEvent {
         val effectiveRequestId = nonBlankRequestId(requestId) ?: generatedCameraRequestId("warm")
-        val pending = PendingResponse<CameraStatusEvent>("camera warm up $effectiveRequestId")
+        val pending = PendingResponse<CameraStatusEvent>("camera warm up $effectiveRequestId", "camera warm up")
         // Guard against a concurrent warm-up reusing the same requestId: a blind put would overwrite
         // (and strand) the first caller's continuation until it times out. Reject the duplicate.
         if (pendingCameraStatusRequests.putIfAbsent(effectiveRequestId, pending) != null) {
@@ -1155,35 +1214,55 @@ class MentraBluetoothSdk private constructor(
     }
 
     suspend fun startStream(request: StreamRequest): StreamStatusEvent {
-        requireGlassesConnected("start stream")
-        if (!streamSession.supported) {
-            throw BluetoothSdkException("stream_control_unsupported", "Update the glasses software before starting a stream.")
-        }
         val message = request.toMap().toMutableMap()
         val streamId = (message["streamId"] as? String)?.takeIf { it.isNotBlank() }
                 ?: "sdk-${UUID.randomUUID()}"
         message["streamId"] = streamId
-        val pending = PendingResponse<StreamStatusEvent>("start stream $streamId")
-        var start: PendingStreamStart? = null
-        try {
-            // seq assignment and the BLE hand-off must be one critical section:
-            // rejectPreemptedStreamStarts only works if seq order equals the
-            // order the commands reach the glasses' FIFO.
-            synchronized(streamStartOrderLock) {
-                val registered = PendingStreamStart(streamStartSeq.incrementAndGet(), pending)
-                pendingStreamStarts[streamId] = registered
-                start = registered
-                deviceManager.startStream(message)
+        return withUsageOutcome(
+            { latencyMs, errorCode, _ ->
+                val glassesNetwork = glassesNetwork()
+                analytics.recordUsage {
+                    streamStartSettled(
+                        streamUrl = request.streamUrl,
+                        width = request.video?.width,
+                        height = request.video?.height,
+                        fps = request.video?.fps,
+                        bitrate = request.video?.bitrate,
+                        captureAudio = request.captureAudio,
+                        glassesNetwork = glassesNetwork,
+                        latencyMs = latencyMs,
+                        errorCode = errorCode,
+                    )
+                }
+            },
+        ) {
+            requireGlassesConnected("start stream")
+            if (!streamSession.supported) {
+                throw BluetoothSdkException("stream_control_unsupported", "Update the glasses software before starting a stream.")
+            }
+            val pending = PendingResponse<StreamStatusEvent>("start stream $streamId", "start stream")
+            val requestedAt = System.currentTimeMillis()
+            analytics.recordUsage { streamRequested(streamId, request.streamUrl, requestedAt) }
+            var start: PendingStreamStart? = null
+            try {
+                // seq assignment and the BLE hand-off must be one critical section:
+                // rejectPreemptedStreamStarts only works if seq order equals the
+                // order the commands reach the glasses' FIFO.
+                synchronized(streamStartOrderLock) {
+                    val registered = PendingStreamStart(streamStartSeq.incrementAndGet(), pending)
+                    pendingStreamStarts[streamId] = registered
+                    start = registered
+                    deviceManager.startStream(message)
+                }
+                pending.await(STREAM_START_TIMEOUT_MS)
+            } finally {
+                start?.let { pendingStreamStarts.remove(streamId, it) }
             }
-            val event = pending.await(STREAM_START_TIMEOUT_MS)
-            return event
-        } finally {
-            start?.let { pendingStreamStarts.remove(streamId, it) }
         }
     }
 
     suspend fun rgbLedControl(request: RgbLedRequest): RgbLedControlResponseEvent {
-        val pending = PendingResponse<RgbLedControlResponseEvent>("RGB LED command ${request.requestId}")
+        val pending = PendingResponse<RgbLedControlResponseEvent>("RGB LED command ${request.requestId}", "RGB LED command")
         pendingRgbLedRequests[request.requestId] = pending
         try {
             deviceManager.rgbLedControl(
@@ -1202,6 +1281,7 @@ class MentraBluetoothSdk private constructor(
     }
 
     suspend fun stopStream(): StreamStatusEvent {
+        analytics.updateUsage { streamStopRequested() }
         val pending = PendingResponse<StreamStatusEvent>("stop stream")
         val targetStreamId = streamSession.currentStreamId
         try {
@@ -1243,6 +1323,16 @@ class MentraBluetoothSdk private constructor(
                 "A video recording command is already waiting for requestId ${request.requestId}.",
             )
         }
+        analytics.updateUsage {
+            videoRequested(
+                request.requestId,
+                request.width,
+                request.height,
+                request.fps,
+                request.save,
+                request.maxRecordingTimeMinutes,
+            )
+        }
         try {
             deviceManager.startVideoRecording(
                     request.requestId,
@@ -1281,6 +1371,7 @@ class MentraBluetoothSdk private constructor(
                 "A video recording command is already waiting for requestId $requestId.",
             )
         }
+        analytics.updateUsage { videoStopRequested(requestId) }
         try {
             deviceManager.stopVideoRecording(requestId, webhookUrl, authToken)
             val timeoutMs =
@@ -1587,6 +1678,7 @@ class MentraBluetoothSdk private constructor(
         Bridge.removeEventSink(bridgeEventSinkId)
         DeviceStore.store.removeListener(storeListenerId)
         analytics.shutdown()
+        updateCheck.stop()
         listeners.clear()
     }
 
@@ -1596,7 +1688,7 @@ class MentraBluetoothSdk private constructor(
                 if (changes["connected"] == false) {
                     resetWifiProtocolSession("", "wifi_session_disconnected")
                 }
-                analytics.observeGlassesStatus(getRawGlassesStatus())
+                analytics.observeGlassesStatus(getRawGlassesStatus(), ::isPhoneBluetoothOff)
                 val state = getState()
                 dispatchToListeners {
                     it.onStateChanged(state)
@@ -1604,6 +1696,12 @@ class MentraBluetoothSdk private constructor(
                 }
             }
             ObservableStore.BLUETOOTH_CATEGORY -> {
+                if (analytics.isEnabled && changes.keys.any { it in MIC_STATE_KEYS }) {
+                    val bluetooth = getRawBluetoothStatus()
+                    val transcribing = bluetooth.shouldSendTranscript || bluetooth.localSttFallbackActive
+                    val now = System.currentTimeMillis()
+                    analytics.recordUsage { observeMic(bluetooth.currentMic, transcribing, now) }
+                }
                 val state = getState()
                 val scanChanged = changes.keys.any { it in SCAN_STATE_KEYS }
                 dispatchToListeners {
@@ -1870,6 +1968,10 @@ class MentraBluetoothSdk private constructor(
             "photo_response" -> {
                 val event = PhotoResponseEvent(data)
                 handlePhotoResponseForRequests(event)
+                val response = event.response
+                if (response is PhotoResponse.Error && event.requestId == BluetoothSdkUsageTracker.LOCAL_PHOTO_REQUEST_ID) {
+                    analytics.recordUsage { buttonPhotoFailed(response.errorCode) }
+                }
                 dispatchToListeners { it.onPhotoResponse(event) }
             }
             "photo_status" -> dispatchToListeners { it.onPhotoStatus(PhotoStatusEvent(data)) }
@@ -1881,6 +1983,8 @@ class MentraBluetoothSdk private constructor(
             "video_recording_status" -> {
                 val event = VideoRecordingStatusEvent(data)
                 handleVideoRecordingStatusForRequests(event)
+                val now = System.currentTimeMillis()
+                analytics.recordUsage { videoStatus(event.requestId, event.status, event.success, now) }
                 dispatchToListeners { it.onVideoRecordingStatus(event) }
             }
             "media_success", "media_error" -> {
@@ -1900,6 +2004,7 @@ class MentraBluetoothSdk private constructor(
                 if (data.containsKey("revision") && !streamSession.accept(data)) return
                 val event = StreamStatusEvent(data)
                 handleStreamStatusForRequests(event)
+                recordStreamStatus(event)
                 dispatchToListeners { it.onStreamStatus(event) }
             }
             "keep_alive_ack" -> {
@@ -1924,6 +2029,23 @@ class MentraBluetoothSdk private constructor(
                         )
                     }
                 }
+                if (analytics.isEnabled) {
+                    val glasses = getRawGlassesStatus()
+                    val now = System.currentTimeMillis()
+                    analytics.recordUsage {
+                        otaStatus(
+                            sessionId = event.sessionId,
+                            status = event.status,
+                            stepType = event.stepType,
+                            totalSteps = event.totalSteps,
+                            errorMessage = event.errorMessage,
+                            fromBuildNumber = glasses.buildNumber,
+                            fromBesFirmwareVersion = glasses.besFirmwareVersion,
+                            fromMtkFirmwareVersion = glasses.mtkFirmwareVersion,
+                            nowMs = now,
+                        )
+                    }
+                }
                 dispatchToListeners { it.onOtaStatus(event) }
             }
             "mic_health" -> {
@@ -1979,6 +2101,75 @@ class MentraBluetoothSdk private constructor(
         }
     }
 
+    private fun recordStreamStatus(event: StreamStatusEvent) {
+        if (!analytics.isEnabled) return
+        val status = event.status
+        val attempt =
+            when (status) {
+                is StreamStatus.Reconnecting -> status.attempt
+                is StreamStatus.Reconnected -> status.attempt
+                else -> null
+            }
+        val errorDetails = event.errorDetails ?: (status as? StreamStatus.Error)?.errorDetails
+        val now = System.currentTimeMillis()
+        analytics.recordUsage {
+            streamStatus(
+                streamId = event.streamId,
+                state = event.state.value,
+                terminal = event.terminal,
+                reconnectAttempt = attempt,
+                bitrate = event.stats?.bitrate,
+                fps = event.stats?.fps,
+                droppedFrames = event.stats?.droppedFrames,
+                temperatureC = event.stats?.temperatureC,
+                errorDetails = errorDetails,
+                nowMs = now,
+            )
+        }
+    }
+
+    private fun glassesNetwork(): String {
+        val glasses = getRawGlassesStatus()
+        return when {
+            glasses.hotspot is HotspotStatus.Enabled -> "hotspot"
+            glasses.wifi is WifiStatus.Connected -> "wifi"
+            else -> "none"
+        }
+    }
+
+    private fun isPhoneBluetoothOff(): Boolean =
+        try {
+            (appContext.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager)?.adapter?.isEnabled == false
+        } catch (_: Exception) {
+            false
+        }
+
+    /**
+     * Runs a glasses command and reports its latency and outcome to usage
+     * analytics. Cancellation is the caller giving up, not a command outcome, so
+     * it is not reported.
+     */
+    private inline fun <T> withUsageOutcome(
+        record: (latencyMs: Long, errorCode: String?, result: T?) -> Unit,
+        block: () -> T,
+    ): T {
+        val startedAt = System.currentTimeMillis()
+        val result =
+            try {
+                block()
+            } catch (error: CancellationException) {
+                throw error
+            } catch (error: Exception) {
+                if (analytics.isEnabled) {
+                    val errorCode = (error as? BluetoothSdkException)?.code ?: error.javaClass.simpleName
+                    record(System.currentTimeMillis() - startedAt, errorCode, null)
+                }
+                throw error
+            }
+        if (analytics.isEnabled) record(System.currentTimeMillis() - startedAt, null, result)
+        return result
+    }
+
     private fun dispatchToListeners(callback: (MentraBluetoothSdkListener) -> Unit) {
         val snapshot = synchronized(listeners) { listeners.toList() }
         val deliver = {

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

@@ -41,6 +41,30 @@ class MentraLocalNetworkModule : Module() {
         Name("MentraLocalNetwork")
         Events("downloadProgress", "networkLost")
 
+        Function("getNetworkDiagnostics") {
+            val manager = connectivityManager()
+            // Sample time marks the beginning of these sequential local OS reads.
+            val sampledAtMs = System.currentTimeMillis()
+            networkDiagnostics(
+                sampledAtMs,
+                manager.boundNetworkForProcess,
+                manager.activeNetwork,
+                synchronized(lock) { localNetwork },
+            ) { network ->
+                manager.getNetworkCapabilities(network)?.let { capabilities ->
+                    mapOf(
+                        "wifi" to capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI),
+                        "cellular" to capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR),
+                        "ethernet" to capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET),
+                        "vpn" to capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN),
+                        "internet" to capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET),
+                        "validated" to capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED),
+                        "captivePortal" to capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL),
+                    )
+                }
+            }
+        }
+
         AsyncFunction("connect") { ssid: String, password: String, promise: Promise ->
             connect(ssid, password, promise)
         }

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

@@ -0,0 +1,25 @@
+package com.mentra.bluetoothsdk
+
+/** Only routing relationships and capabilities cross the bridge, never network identities. */
+internal fun <N> networkDiagnostics(
+    sampledAtMs: Long,
+    processBound: N?,
+    activeNetwork: N?,
+    glassesLocal: N?,
+    capabilities: (N) -> Map<String, Boolean>?,
+): Map<String, Any?> {
+    fun observation(network: N?): Map<String, Any?> = mapOf(
+        "present" to (network != null),
+        "capabilities" to network?.let(capabilities),
+    )
+    fun same(first: N?, second: N?): Boolean = first != null && first == second
+    return mapOf(
+        "sampledAtMs" to sampledAtMs,
+        "processBound" to observation(processBound),
+        "activeNetwork" to observation(activeNetwork),
+        "glassesLocal" to observation(glassesLocal),
+        "processBoundMatchesActive" to same(processBound, activeNetwork),
+        "processBoundMatchesGlassesLocal" to same(processBound, glassesLocal),
+        "activeNetworkMatchesGlassesLocal" to same(activeNetwork, glassesLocal),
+    )
+}

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

@@ -6,13 +6,14 @@ internal sealed interface VersionInfoAccumulatorOutcome {
     data class Complete(val result: VersionInfoResult) : VersionInfoAccumulatorOutcome
 }
 
-/** One request, explicit modern completion, or the deployed legacy chunk-3 terminal boundary. */
+/** One request, explicit modern completion, or the legacy firmware's terminal chunk. */
 internal class VersionInfoResponseAccumulator(private val expectedRequestId: String) {
     private val values = mutableMapOf<String, Any>()
     private val chunks = mutableMapOf<Int, Map<String, Any>>()
     private var count: Int? = null
     private var sid: String? = null
     private var legacyStarted = false
+    private var legacyTwoChunkResponse = false
     private var completed = false
 
     fun accept(event: Map<String, Any>): VersionInfoAccumulatorOutcome {
@@ -41,10 +42,20 @@ internal class VersionInfoResponseAccumulator(private val expectedRequestId: Str
         if (count != null) return VersionInfoAccumulatorOutcome.Ignored
         when (event[RESPONSE_CHUNK_KEY] as? String ?: "version_info") {
             "version_info" -> { values.clear(); merge(event); return finish() }
-            "version_info_1" -> { values.clear(); legacyStarted = true; merge(event) }
+            "version_info_1" -> {
+                values.clear()
+                legacyStarted = true
+                legacyTwoChunkResponse = event["buildNumber"] == "27"
+                merge(event)
+            }
             "version_info_2" -> {
                 if (!legacyStarted) return VersionInfoAccumulatorOutcome.Ignored
+                // Factory ASG27 sends only chunks 1 and 2. Its second chunk carries the
+                // OTA URL and legacy firmware version; ASG31+ moves firmware to chunk 3.
                 merge(event)
+                if (legacyTwoChunkResponse && values["buildNumber"] == "27" &&
+                    !(event["otaVersionUrl"] as? String).isNullOrBlank()
+                ) return finish()
             }
             "version_info_3" -> {
                 if (!legacyStarted) return VersionInfoAccumulatorOutcome.Ignored

package/android/src/main/java/com/mentra/bluetoothsdk/debug/BleTraceLogger.kt

@@ -108,6 +108,9 @@ object BleTraceLogger {
     }
 
     private fun sanitizeValue(key: String?, value: Any?): Any? {
+        // Scan security metadata is a boolean, not a credential. Keep the exact
+        // typed field while still redacting string/unknown values under this key.
+        if (key == "requiresPassword" && value is Boolean) return value
         if (key != null && sensitiveKeyParts.any { key.contains(it, ignoreCase = true) }) {
             return "<redacted>"
         }

package/android/src/main/java/com/mentra/bluetoothsdk/requests/DisplayRequests.kt

@@ -1,7 +1,7 @@
 package com.mentra.bluetoothsdk
 
 internal object DashboardContentFormatter {
-    const val STATUS_HEADER = "\$TIME12$ \$DATE$ \$GBATT$ \$CONNECTION_STATUS$"
+    const val STATUS_HEADER = "\$TIME12$ \$DATE$ \$GBATT$"
 
     fun template(content: String): String =
         if (content.isEmpty()) STATUS_HEADER else "$STATUS_HEADER\n\n$content"

package/android/src/main/java/com/mentra/bluetoothsdk/services/Foreground.kt

@@ -13,6 +13,8 @@ import android.os.IBinder
 import androidx.core.app.NotificationCompat
 import androidx.core.content.ContextCompat
 import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.DeviceManager
+import com.mentra.bluetoothsdk.DeviceStore
 import com.mentra.bluetoothsdk.debug.BleTraceLogger
 
 class ForegroundService : Service() {
@@ -107,9 +109,40 @@ class ForegroundService : Service() {
         }
         // Re-check permissions in case they changed
         startForegroundWithAutoDetectedType()
+        // A null intent is Android restarting START_STICKY after process death.
+        // Do not wait for an Activity/Expo module to restore the native BLE owner.
+        if (intent == null && !DeviceManager.isInitialized()) {
+            val settings = G2ConnectionRecovery(this).read()
+            if (settings != null && !startHostRuntimeRecovery()) {
+                Bridge.initialize(applicationContext)
+                settings.forEach { (key, value) -> DeviceStore.set("bluetooth", key, value) }
+                Bridge.log("ForegroundService: restoring G2 connection after process restart")
+                try {
+                    DeviceManager.getInstance().connectDefault()
+                } catch (error: Exception) {
+                    Bridge.log("ForegroundService: G2 recovery failed: ${error.message}")
+                }
+            }
+        }
         return START_STICKY
     }
 
+    private fun startHostRuntimeRecovery(): Boolean {
+        // Keep the standalone SDK free of React dependencies. The Mentra App
+        // opts in with a private headless service declared by its host module.
+        val serviceName = packageManager.getApplicationInfo(packageName, PackageManager.GET_META_DATA)
+                .metaData?.getString("com.mentra.bluetoothsdk.RUNTIME_RECOVERY_SERVICE")
+                ?: return false
+        return try {
+            if (startService(Intent().setClassName(packageName, serviceName)) == null) return false
+            Bridge.log("ForegroundService: requested host JavaScript runtime recovery")
+            true
+        } catch (error: Exception) {
+            Bridge.log("ForegroundService: host runtime recovery could not start: ${error.message}")
+            false
+        }
+    }
+
     private fun startForegroundWithAutoDetectedType() {
         startForegroundWithType(detectServiceType())
     }

package/android/src/main/java/com/mentra/bluetoothsdk/services/G2ConnectionRecovery.kt

@@ -0,0 +1,47 @@
+package com.mentra.bluetoothsdk.services
+
+import android.content.Context
+import com.mentra.bluetoothsdk.utils.DeviceTypes
+import org.json.JSONObject
+
+/** Native recovery of the last active G2 link when Android restarts our sticky service. */
+internal class G2ConnectionRecovery(context: Context) {
+    private val preferences = context.getSharedPreferences("g2_connection_recovery", Context.MODE_PRIVATE)
+
+    companion object {
+        // Deliberately exclude transient connection flags, mic intent, tokens and pending pairing.
+        internal val keys = setOf(
+            "default_wearable", "device_name", "device_address", "project_name",
+            "brightness", "auto_brightness", "dashboard_height", "dashboard_depth",
+            "head_up_angle", "use_native_dashboard", "twelve_hour_time", "metric_system",
+            "screen_disabled", "power_saving_mode", "lc3_frame_size",
+        )
+    }
+
+    fun save(settings: Map<String, Any>) {
+        if (settings["default_wearable"] != DeviceTypes.G2 ||
+            (settings["device_name"] as? String).isNullOrBlank()) {
+            clear()
+            return
+        }
+        val snapshot = settings.filterKeys { it in keys }
+        preferences.edit().putString("snapshot", JSONObject(snapshot).toString()).apply()
+    }
+
+    fun clear() {
+        preferences.edit().remove("snapshot").apply()
+    }
+
+    fun read(): Map<String, Any>? {
+        val raw = preferences.getString("snapshot", null) ?: return null
+        return try {
+            val json = JSONObject(raw)
+            if (json.optString("default_wearable") != DeviceTypes.G2 ||
+                json.optString("device_name").isBlank()) return null
+            keys.filter { json.has(it) && !json.isNull(it) }.associateWith { json.get(it) }
+        } catch (_: Exception) {
+            clear()
+            null
+        }
+    }
+}