@mentra/bluetooth-sdk 3.2.1-dev.314 → 3.2.1

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

@@ -13,6 +13,7 @@ import androidx.core.content.ContextCompat
 import com.mentra.bluetoothsdk.controllers.ControllerManager
 import com.mentra.bluetoothsdk.controllers.R1
 import com.mentra.bluetoothsdk.services.ForegroundService
+import com.mentra.bluetoothsdk.services.G2ConnectionRecovery
 import com.mentra.bluetoothsdk.services.PhoneMic
 import com.mentra.bluetoothsdk.sgcs.Ar99
 import com.mentra.bluetoothsdk.sgcs.G1
@@ -34,7 +35,10 @@ import com.mentra.bluetoothsdk.utils.MicTypes
 import com.mentra.bluetoothsdk.utils.PhoneAudioMonitor
 import com.mentra.lc3Lib.Lc3Cpp
 import com.mentra.bluetoothsdk.stt.SherpaOnnxTranscriber
+import kotlin.coroutines.resume
+import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.withContext
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import java.text.SimpleDateFormat
@@ -45,12 +49,15 @@ import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
 import kotlin.jvm.JvmStatic
 
-class DeviceManager {
+class DeviceManager internal constructor(initializeHardware: Boolean) {
+    constructor() : this(initializeHardware = true)
     companion object {
 
         @Volatile
         private var _instance: DeviceManager? = null
 
+        internal fun isInitialized(): Boolean = _instance != null
+
         @JvmStatic
         fun getInstance(): DeviceManager {
             return _instance
@@ -59,6 +66,10 @@ class DeviceManager {
     }
 
     // MARK: - Unique (Android)
+    private val connectionRecovery = G2ConnectionRecovery(Bridge.getContext())
+    private val recoveryLock = Any()
+    private var recoverG2Connection = false
+    private var recoveryListenerId: String? = null
     private var serviceStarted = false
     private val mainHandler = Handler(Looper.getMainLooper())
     private val executor: ExecutorService = Executors.newSingleThreadExecutor()
@@ -79,7 +90,8 @@ class DeviceManager {
     // MARK: - End Unique
 
     // MARK: - Properties
-    var sgc: SGCManager? = null
+    // Read by the welcome executor as well as device lifecycle handlers.
+    @Volatile var sgc: SGCManager? = null
     var controller: ControllerManager? = null
 
     // settings:
@@ -283,7 +295,22 @@ class DeviceManager {
 
     init {
         Bridge.log("DeviceManager: init()")
+        recoveryListenerId = DeviceStore.store.addListener { category, changes ->
+            if (category == "bluetooth" && changes.keys.any { it in G2ConnectionRecovery.keys }) {
+                synchronized(recoveryLock) {
+                    if (recoverG2Connection) {
+                        connectionRecovery.save(DeviceStore.store.getCategory("bluetooth"))
+                    }
+                }
+            }
+        }
         initializeViewStates()
+        if (initializeHardware) initializeHardwareServices()
+    }
+
+    // Keep host routing usable without starting audio codecs, receivers or services.
+    // The public constructor always initializes the hardware environment.
+    private fun initializeHardwareServices() {
         startForegroundService()
         // setupPermissionMonitoring()
         setupBluetoothStateMonitoring()
@@ -1354,7 +1381,8 @@ class DeviceManager {
             Bridge.log("MAN: Cleaning up previous sgc type: ${sgc?.type}")
             sgc?.cleanup()
             sgc = null
-            resetSystemTimeSync()
+            DeviceStore.apply("glasses", "micEnabled", false)
+            resetConnectionReadyState()
         }
 
         if (sgc != null) {
@@ -1477,12 +1505,16 @@ class DeviceManager {
             return
         }
 
+        // A new identity must never inherit the previous glasses' address when
+        // pairing supplied only a name. Same-device reconnects retain their cache.
+        val identityChanged = pendingDeviceName.isNotEmpty() &&
+            (pendingDeviceName != deviceName || sgc?.type != defaultWearable)
+        if (identityChanged || pendingDeviceAddress.isNotEmpty()) {
+            deviceAddress = pendingDeviceAddress
+        }
         if (pendingDeviceName.isNotEmpty()) {
             deviceName = pendingDeviceName
         }
-        if (pendingDeviceAddress.isNotEmpty()) {
-            deviceAddress = pendingDeviceAddress
-        }
         clearPendingConnection()
 
         val readyKey = "${sgc?.type}:${deviceName}"
@@ -1497,6 +1529,10 @@ class DeviceManager {
         Bridge.log("MAN: handleDeviceReady() ${sgc?.type}")
         resetMicHealth()
         defaultWearable = sgc?.type ?: ""
+        synchronized(recoveryLock) {
+            recoverG2Connection = defaultWearable == DeviceTypes.G2
+            connectionRecovery.save(DeviceStore.store.getCategory("bluetooth"))
+        }
         searching = false
 
         syncSystemTimeOnceForConnection(readyKey)
@@ -1504,6 +1540,7 @@ class DeviceManager {
         // re-apply display height/depth after reconnection
         mainHandler.postDelayed(
             {
+                val device = sgc ?: return@postDelayed
                 val h =
                     (DeviceStore.store.get("bluetooth", "dashboard_height") as? Number)
                         ?.toInt()
@@ -1512,19 +1549,24 @@ class DeviceManager {
                     (DeviceStore.store.get("bluetooth", "dashboard_depth") as? Number)
                         ?.toInt()
                         ?: dashboardDepth // canonical default (2), not 1
-                val d = rawDepth.coerceIn(1, 4)
-                sgc?.setDashboardPosition(h, d)
+                val d = if (device.type == DeviceTypes.NIMO) rawDepth.coerceIn(0, 10) else rawDepth.coerceIn(1, 4)
+                device.setDashboardPosition(h, d)
             },
             2000
         )
 
-        // Show welcome message on first connect for all display glasses
+        // A full-canvas device can opt out so this temporary message does not
+        // erase the host's connected-edge scene replay.
         if (shouldSendBootingMessage) {
             shouldSendBootingMessage = false
-            executor.execute {
-                sgc?.sendTextWall("// MentraOS Connected")
-                Thread.sleep(3000)
-                sgc?.clearDisplay()
+            val device = sgc
+            if (device?.showConnectionConfirmation == true) {
+                executor.execute {
+                    if (sgc !== device) return@execute
+                    device.sendTextWall("// MentraOS Connected")
+                    Thread.sleep(3000)
+                    if (sgc === device) device.clearDisplay()
+                }
             }
         }
 
@@ -1537,10 +1579,11 @@ class DeviceManager {
             handleMach1Ready() // Z100 uses same initialization as Mach1
         }
 
-        // Re-apply microphone settings after reconnection
-        // Cache was cleared on disconnect, so this will definitely send commands
+        // Disconnect clears micEnabled but preserves the consumers' audio requests.
+        // Recompute that derived flag before selecting a microphone; replaying an
+        // unchanged should_send_* setting is deduplicated by DeviceStore.apply().
         Bridge.log("MAN: Re-applying microphone settings after reconnection")
-        updateMicState()
+        setMicState()
 
         // send to the server our battery status:
         Bridge.sendBatteryStatus(sgc?.batteryLevel ?: -1, false)
@@ -1580,7 +1623,11 @@ class DeviceManager {
         mainHandler.postDelayed(sync, 3000)
     }
 
-    private fun resetSystemTimeSync() {
+    private fun resetConnectionReadyState() {
+        // Suppress duplicate readiness only within one connection, never across
+        // a genuine disconnect/reconnect of the same glasses inside two seconds.
+        lastReadyHandledKey = ""
+        lastReadyHandledAtMs = 0L
         pendingSystemTimeSync?.let { mainHandler.removeCallbacks(it) }
         pendingSystemTimeSync = null
         lastSystemTimeSyncConnectionKey = ""
@@ -1598,7 +1645,7 @@ class DeviceManager {
 
     fun handleDeviceDisconnected() {
         Bridge.log("MAN: Device disconnected")
-        resetSystemTimeSync()
+        resetConnectionReadyState()
         resetMicHealth()
         DeviceStore.apply("glasses", "headUp", false)
         DeviceStore.apply(
@@ -1677,7 +1724,7 @@ class DeviceManager {
         dashboardSceneCleanupPending = false
         val elementIds = pendingDashboardSceneElementIds.toList()
         pendingDashboardSceneElementIds.clear()
-        if (elementIds.isNotEmpty()) {
+        if (elementIds.isNotEmpty() && sgc?.sceneHandoffRequiresClear == true) {
             sgc?.clearSceneElements(elementIds)
         }
     }
@@ -1714,7 +1761,7 @@ class DeviceManager {
             sceneStates[stateIndex] = null
             if (stateIndex == 1 && dashboardSceneCleanupPending) {
                 pendingDashboardSceneElementIds.addAll(prevFrame.elements.map { it.id })
-            } else if (layoutType != "clear_view") {
+            } else if (layoutType != "clear_view" && shouldClearSceneHandoff(stateIndex)) {
                 sgc?.clearSceneElements(prevFrame.elements.map { it.id })
             }
         }
@@ -1781,7 +1828,7 @@ class DeviceManager {
             val prevLegacyType = viewStates[stateIndex].layoutType
             val cleanupDeferred = stateIndex == 1 && dashboardSceneCleanupPending
             if (
-                !cleanupDeferred &&
+                !cleanupDeferred && shouldClearSceneHandoff(stateIndex) &&
                     prevLegacyType.isNotEmpty() &&
                     prevLegacyType != "clear_view" &&
                     prevLegacyType != "scene"
@@ -1797,7 +1844,7 @@ class DeviceManager {
             // blank.
             if (stateIndex == 1 && dashboardSceneCleanupPending) {
                 pendingDashboardSceneElementIds.addAll(prevFrame.elements.map { it.id })
-            } else {
+            } else if (shouldClearSceneHandoff(stateIndex)) {
                 sgc?.clearSceneElements(prevFrame.elements.map { it.id })
             }
             frame = frame.copy(replay = true, elements = frame.elements.map { it.copy(change = "created") })
@@ -1816,6 +1863,15 @@ class DeviceManager {
         }
     }
 
+    // Hidden-view updates only change their replay slot. They must never clear
+    // the visible view, and full-frame adapters need no separate handoff sweep.
+    private fun shouldClearSceneHandoff(stateIndex: Int): Boolean {
+        val visibleIndex = if (headUp && contextualDashboard) 1 else 0
+        val device = sgc ?: return false
+        return stateIndex == visibleIndex && !screenDisabled && device.fullyBooted &&
+            !device.type.contains(DeviceTypes.SIMULATED) && device.sceneHandoffRequiresClear
+    }
+
     /** Guarded scene dispatch — mirrors sendCurrentState's send conditions. */
     private fun dispatchSceneFrame(stateIndex: Int, frame: SceneFrame) {
         if (screenDisabled) return
@@ -2389,10 +2445,20 @@ class DeviceManager {
     }
 
     fun disconnect(clearPendingIdentity: Boolean = true) {
+        synchronized(recoveryLock) {
+            recoverG2Connection = false
+            connectionRecovery.clear()
+        }
         sgc?.clearDisplay()
-        sgc?.disconnect()
+        // NIMO owns a background canvas encoder and this path discards its instance.
+        // A link-level reconnect keeps the instance (and encoder) through disconnect().
+        val device = sgc
+        if (device is Nimo) device.cleanup() else device?.disconnect()
         sgc = null // Clear the SGC reference after disconnect
-        resetSystemTimeSync()
+        // This cache belongs to the discarded connection. Keep consumer demand,
+        // but require a new mic-enable command when replacement glasses are ready.
+        DeviceStore.apply("glasses", "micEnabled", false)
+        resetConnectionReadyState()
         resetMicHealth()
         searching = false
         micEnabled = false
@@ -2439,7 +2505,42 @@ class DeviceManager {
         controller = null
     }
 
+    private var unpairInProgress = false
+
+    /** Explicit user Unpair, separate from passive pairing cleanup and logout. */
+    suspend fun unpair() = withContext(Dispatchers.Main) {
+        check(!unpairInProgress) { "Unpair already in progress" }
+        unpairInProgress = true
+        try {
+            val target = sgc
+            val nimo = target as? Nimo
+            val savedNimoAddress = when {
+                defaultWearable == DeviceTypes.NIMO -> deviceAddress
+                pendingWearable == DeviceTypes.NIMO -> pendingDeviceAddress
+                else -> null
+            }
+            if (nimo != null) {
+                suspendCancellableCoroutine<Boolean> { continuation ->
+                    nimo.resetForUnpair { if (continuation.isActive) continuation.resume(it) }
+                }
+                check(sgc === target) { "Glasses changed during Unpair" }
+                // Drop the encrypted link before removing the phone's bond.
+                nimo.disconnect()
+                nimo.removeBluetoothBond()
+            } else if (target == null && savedNimoAddress != null) {
+                Nimo.removeBluetoothBond(savedNimoAddress)
+            }
+            forget()
+        } finally {
+            unpairInProgress = false
+        }
+    }
+
     fun forget() {
+        synchronized(recoveryLock) {
+            recoverG2Connection = false
+            connectionRecovery.clear()
+        }
         Bridge.log("MAN: Forgetting smart glasses")
 
         val live = sgc as? MentraLive
@@ -2451,7 +2552,8 @@ class DeviceManager {
             // session state without calling disconnect() again (that would hit a dead instance
             // and leave a destroyed MentraLive retained for the next scan).
             sgc = null
-            resetSystemTimeSync()
+            DeviceStore.apply("glasses", "micEnabled", false)
+            resetConnectionReadyState()
             searching = false
             micEnabled = false
             updateMicState()
@@ -2554,6 +2656,8 @@ class DeviceManager {
 
     // MARK: Cleanup
     fun cleanup() {
+        recoveryListenerId?.let { DeviceStore.store.removeListener(it) }
+        recoveryListenerId = null
         stopBluetoothStateMonitoring()
 
         micReinitRunnable?.let { mainHandler.removeCallbacks(it) }

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

@@ -142,6 +142,7 @@ object DeviceStore {
         store.set("bluetooth", "gallery_mode", true)
         store.set("bluetooth", "voice_activity_detection_enabled", BluetoothSdkDefaults.VOICE_ACTIVITY_DETECTION_ENABLED)
         store.set("bluetooth", "loudness_gate_enabled", BluetoothSdkDefaults.LOUDNESS_GATE_ENABLED)
+        store.set("bluetooth", "auto_power_off_enabled", BluetoothSdkDefaults.AUTO_POWER_OFF_ENABLED)
         store.set("bluetooth", "screen_disabled", false)
         store.set("bluetooth", "button_photo_size", "max")
         store.set("bluetooth", "button_max_recording_time", 10)
@@ -219,14 +220,30 @@ object DeviceStore {
             }
 
             // BLUETOOTH:
+            "bluetooth" to "contextual_dashboard" -> {
+                if (value is Boolean) {
+                    CoroutineScope(Dispatchers.Main.immediate).launch {
+                        // The setting changes the selected view even without a new head event.
+                        // Re-read state on Main and retain the manager's readiness/display guards.
+                        if (store.get("glasses", "headUp") == true) {
+                            DeviceManager.getInstance().sendCurrentState()
+                        }
+                    }
+                }
+            }
             "bluetooth" to "brightness" -> {
                 val b = (value as? Number)?.toInt()  ?: 50
                 val auto = (store.get("bluetooth", "auto_brightness") as? Boolean) ?: true
                 CoroutineScope(Dispatchers.Main).launch {
-                    DeviceManager.getInstance().sgc?.setBrightness(b, auto)
-                    DeviceManager.getInstance().sgc?.sendTextWall("Set brightness to $b%")
-                    delay(800) // 0.8 seconds
-                    DeviceManager.getInstance().sgc?.clearDisplay()
+                    val device = DeviceManager.getInstance().sgc ?: return@launch
+                    device.setBrightness(b, auto)
+                    if (device.showBrightnessConfirmation) {
+                        device.sendTextWall("Set brightness to $b%")
+                        delay(800) // 0.8 seconds
+                        if (DeviceManager.getInstance().sgc === device) {
+                            device.clearDisplay()
+                        }
+                    }
                 }
             }
             "bluetooth" to "auto_brightness" -> {
@@ -234,16 +251,17 @@ object DeviceStore {
                 val auto = (value as? Boolean) ?: true
                 val autoBrightnessChanged = (oldValue as? Boolean) != auto
                 CoroutineScope(Dispatchers.Main).launch {
-                    DeviceManager.getInstance().sgc?.setBrightness(b, auto)
-                    if (autoBrightnessChanged) {
-                        DeviceManager.getInstance()
-                                .sgc
-                                ?.sendTextWall(
-                                        if (auto) "Enabled auto brightness"
-                                        else "Disabled auto brightness"
-                                )
+                    val device = DeviceManager.getInstance().sgc ?: return@launch
+                    device.setBrightness(b, auto)
+                    if (autoBrightnessChanged && device.showBrightnessConfirmation) {
+                        device.sendTextWall(
+                                if (auto) "Enabled auto brightness"
+                                else "Disabled auto brightness"
+                        )
                         delay(800) // 0.8 seconds
-                        DeviceManager.getInstance().sgc?.clearDisplay()
+                        if (DeviceManager.getInstance().sgc === device) {
+                            device.clearDisplay()
+                        }
                     }
                 }
             }
@@ -291,6 +309,12 @@ object DeviceStore {
             "bluetooth" to "loudness_gate_enabled" -> {
                 DeviceManager.getInstance().sgc?.sendLoudnessGateSetting()
             }
+            "bluetooth" to "auto_power_off_enabled" -> {
+                Bridge.log(
+                        "DeviceStore: auto_power_off_enabled changed to $value — sending cs_swit type 11"
+                )
+                DeviceManager.getInstance().sgc?.sendAutoPowerOffSetting()
+            }
             // Deliberately has no seeded default above: the key starts absent so
             // that a session where the engine has not authorized tuning can only
             // ever send a reset.

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

@@ -3,8 +3,8 @@ package com.mentra.bluetoothsdk
 /** Generated from /changelogs. Do not edit directly. */
 internal val GENERATED_RELEASE_CHANGELOGS: List<ReleaseChangelog> =
     listOf(
-        ReleaseChangelog(version = "3.2.1", markdown = "This release is under active development. User-facing changes will be documented as they land."),
-        ReleaseChangelog(version = "3.2.0", markdown = "This release is under active development. User-facing changes will be documented as they land.\n\n- Breaking Bluetooth SDK change: `forgetWifiNetwork(ssid)` now returns `WifiForgetResult` instead of `WifiStatusChangeEvent`. Migrate status-only consumers to the semantic `outcome`; the requested network remains `ssid`, while optional post-command connectivity is reported by `connected`, `currentSsid`, and `localIp`."),
+        ReleaseChangelog(version = "3.2.1", markdown = "- **Livestreamer:** \"Stream Here\" now works without a Wi-Fi network. Improved stream startup and connection reliability.\n- **Photos and gallery:** More reliable photo capture and gallery syncing.\n- **Mentra AI:** Reliability improvements and bug fixes.\n- **Miniapps:** Smoother transitions, with back buttons and gestures that take you to the previous screen inside a miniapp.\n- **Pairing and connections:** Improved G1 pairing and G2 background reconnection.\n- **Glasses updates:** Fixed repeated update checks and improved recovery after interrupted updates.\n- **Mentra Maps:** Bug fixes.\n- **NIMO:** Improved text and map layouts.\n- **Self-hosting:** Connect the Mentra App to your own self-hosted Mentra backend."),
+        ReleaseChangelog(version = "3.2.0", markdown = "- Improved glasses connectivity and Wi-Fi setup."),
         ReleaseChangelog(version = "3.1.1", markdown = "- Improved Google login on iOS.\n- Pairing no longer requires phone microphone access."),
         ReleaseChangelog(version = "3.1.0", markdown = "**Mentra App and glasses**\n\n- Improved glasses pairing and reconnection, including on iPad.\n- Improved Android background reliability for captions and miniapps.\n- Added Xingyi AR99 support.\n- More reliable photo and video capture, with improved shutter sounds and privacy-light timing. Taking photos no longer interrupts your running miniapp.\n- Added video thumbnails and smoother gallery browsing.\n- Easier Mentra Live updates through your phone, with clearer progress and better recovery from interruptions.\n\n**Miniapp updates**\n\n- **Mentra AI:** Control whether photos are included with questions. Improved visual answers and connected-app follow-ups.\n- **Captions:** Added offline transcription settings and top/bottom positioning on supported displays.\n- **Translation:** Restored all 60 languages.\n- **Mentra Maps:** Clearer directions on G1/G2, less display flickering, and improved Android offline routing.\n- **Livestreamer:** More video-quality controls and custom streaming options, plus improved startup and sharing.\n- **Merge:** Tap to expand an insight; swipe down or back to dismiss it.\n- **Mentra Notes:** Smoother back navigation.\n- **Recorder:** Fixed audio sharing."),
     )

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

@@ -3,9 +3,9 @@ package com.mentra.bluetoothsdk
 /** Generated by release CI. Do not edit in a release checkout. */
 internal object GeneratedReleaseMetadata {
     const val FAMILY_BASE_VERSION: String = "3.2.1"
-    const val RELEASE_IDENTITY: String = "3.2.1-dev.314"
-    const val RELEASE_SET_ID: String = "mentra-3.2.1-dev.314"
-    const val SOURCE_COMMIT: String = "00ab17c37df5902fbdb1a5824a41288b6850acc5"
-    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-dev.314.json"
-    const val OTA_MANIFEST_SHA256: String = "1062c560fcced026e5b43245e84cdd5febfd603f3ad19fbebef8fac455ba21d6"
+    const val RELEASE_IDENTITY: String = "3.2.1"
+    const val RELEASE_SET_ID: String = "mentra-3.2.1"
+    const val SOURCE_COMMIT: String = "be56e1456c69f681985642f376ed3d397ec022cc"
+    const val OTA_MANIFEST_URL: String = "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-beta.578.json"
+    const val OTA_MANIFEST_SHA256: String = "21af62269e29fd2ee6b9737745a895694bc221672b191d80795057b5a832f400"
 }

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

@@ -651,6 +651,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 " +

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/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
+        }
+    }
+}

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

@@ -1370,8 +1370,8 @@ class G1 : SGCManager() {
         context!!.registerReceiver(bondingReceiver, filter)
         isBondingReceiverRegistered = true
 
-        preferredG1DeviceId = DeviceStore.get("bluetooth", "device_name") as String?
-
+        // Keep the target supplied by connectById. device_name still belongs to
+        // the previous pairing until DeviceManager promotes the ready device.
         if (!bluetoothAdapter!!.isEnabled()) {
             return
         }