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

package/android/src/testDebug/java/com/mentra/bluetoothsdk/sgcs/NimoLifecycleTest.kt

@@ -0,0 +1,288 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothGattCharacteristic
+import org.robolectric.shadows.ShadowBluetoothGatt
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.ContextWrapper
+import android.content.SharedPreferences
+import android.os.Handler
+import android.os.Looper
+import androidx.test.core.app.ApplicationProvider
+import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.DeviceManager
+import com.mentra.bluetoothsdk.DeviceStore
+import com.mentra.bluetoothsdk.utils.ConnTypes
+import java.io.File
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.LooperMode
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+@LooperMode(LooperMode.Mode.PAUSED)
+class NimoLifecycleTest {
+  private class TrackingContext(base: Context) : ContextWrapper(base) {
+    val unregisterLoopers = mutableListOf<Looper?>()
+    val preferenceLoopers = mutableListOf<Looper?>()
+    override fun getApplicationContext(): Context = this
+    override fun getSharedPreferences(name: String, mode: Int): SharedPreferences {
+      if (name == "NimoPrefs") preferenceLoopers.add(Looper.myLooper())
+      return super.getSharedPreferences(name, mode)
+    }
+    override fun unregisterReceiver(receiver: BroadcastReceiver) {
+      unregisterLoopers.add(Looper.myLooper())
+      super.unregisterReceiver(receiver)
+    }
+  }
+
+  private lateinit var context: TrackingContext
+  private lateinit var nimo: Nimo
+  private lateinit var encoderThread: Thread
+  private lateinit var manager: DeviceManager
+  private var previousManager: DeviceManager? = null
+  private lateinit var diagnostics: NimoDiagnostics
+  private lateinit var captureDirectory: File
+  private lateinit var writeCompleted: () -> Unit
+  private var writes = 0
+  private val storeLoopers = mutableListOf<Looper?>()
+  private var listener: String? = null
+
+  @Before fun setup() {
+    context = TrackingContext(ApplicationProvider.getApplicationContext())
+    Bridge.initialize(context)
+    manager = DeviceManager(initializeHardware = false)
+    DeviceManager::class.java.getDeclaredField("_instance").apply { isAccessible = true }.let {
+      previousManager = it.get(null) as DeviceManager?
+      it.set(null, manager)
+    }
+    val threadsBefore = Thread.getAllStackTraces().keys
+    nimo = Nimo()
+    encoderThread = Thread.getAllStackTraces().keys.single {
+      it.name == "NimoCanvasEncoder" && it !in threadsBefore
+    }
+    context.getSharedPreferences("NimoPrefs", Context.MODE_PRIVATE).edit()
+      .putString("nimo_lastDeviceAddress", "00:11:22:33:44:55")
+      .putString("nimo_lastDeviceName", "Nimo-test")
+      .commit()
+    DeviceStore.set("glasses", "connected", true)
+    DeviceStore.set("glasses", "fullyBooted", true)
+    DeviceStore.set("glasses", "connectionState", ConnTypes.CONNECTED)
+    listener = DeviceStore.store.addListener { category, _ ->
+      if (category == "glasses") storeLoopers.add(Looper.myLooper())
+    }
+    diagnostics = NimoDiagnostics(context, Handler(Looper.getMainLooper()), send = { _, completed ->
+      writes += 1
+      writeCompleted = completed
+      true
+    })
+    diagnostics.connected(512)
+    // Install the real debug collaborator without requiring a Bluetooth radio handshake.
+    Nimo::class.java.getDeclaredField("diagnostics").apply { isAccessible = true }
+      .set(nimo, diagnostics)
+    val root = File(context.filesDir, "nimo-framebuffer")
+    val previous = root.listFiles()?.map { it.name }?.toSet() ?: emptySet()
+    // Receiver permission enforcement is a device test; this starts its real capture path.
+    NimoDiagnostics::class.java.getDeclaredMethod("start", String::class.java)
+      .apply { isAccessible = true }.invoke(diagnostics, "capture")
+    captureDirectory = root.listFiles()!!.single { it.name !in previous }
+    assertEquals(1, writes)
+  }
+
+  @After fun dispose() {
+    nimo.cleanup()
+    Shadows.shadowOf(Looper.getMainLooper()).idle()
+    encoderThread.join(1_000)
+    listener?.let { DeviceStore.store.removeListener(it) }
+    manager.cleanup()
+    DeviceManager::class.java.getDeclaredField("_instance").apply { isAccessible = true }
+      .set(null, previousManager)
+  }
+
+  @Test fun offMainDisconnectCompletesOnMainAndInterruptsActiveCapture() {
+    runOffMain { nimo.disconnect() }
+    assertDisconnectedOnMain()
+    assertRememberedDevice()
+  }
+
+  @Test fun offMainForgetClearsRememberedDeviceAfterMainThreadTeardown() {
+    runOffMain { nimo.forget() }
+    assertDisconnectedOnMain()
+    val prefs = context.getSharedPreferences("NimoPrefs", Context.MODE_PRIVATE)
+    assertFalse(prefs.contains("nimo_lastDeviceAddress"))
+    assertFalse(prefs.contains("nimo_lastDeviceName"))
+    assertTrue(context.preferenceLoopers.all { it === Looper.getMainLooper() })
+  }
+
+  @Test fun offMainCleanupClosesDiagnosticsAfterMainThreadTeardown() {
+    runOffMain { nimo.cleanup() }
+    assertDisconnectedOnMain()
+    assertRememberedDevice()
+    encoderThread.join(1_000)
+    assertFalse("Cleanup left its encoder thread alive", encoderThread.isAlive)
+    // A closed diagnostic cannot register another receiver or start a new capture.
+    diagnostics.connected(512)
+    NimoDiagnostics::class.java.getDeclaredMethod("start", String::class.java)
+      .apply { isAccessible = true }.invoke(diagnostics, "capture")
+    assertEquals(1, writes)
+  }
+
+  @Test fun resetForUnpairOfflineDoesNotSendFactoryCommand() {
+    val results = mutableListOf<Boolean>()
+    nimo.resetForUnpair { results.add(it) }
+    assertEquals(listOf(false), results)
+  }
+
+  @Test fun explicitResetWaitsForMatchingAckAndCompletesOnlyOnce() {
+    val frames = readyForReset()
+    val results = mutableListOf<Boolean>()
+    nimo.resetForUnpair { results.add(it) }
+    Shadows.shadowOf(Looper.getMainLooper()).idle()
+    assertTrue(results.isEmpty())
+    assertArrayEquals(byteArrayOf(8, 3, 0, 0), frames.single().drop(8).toByteArray())
+    assertEquals(2, frames.single()[1].toInt())
+    respond(3, 1, 0)
+    assertTrue(results.isEmpty())
+    respond(8, 3, 0)
+    respond(8, 3, 0)
+    assertEquals(listOf(true), results)
+    Shadows.shadowOf(Looper.getMainLooper()).idleFor(6, TimeUnit.SECONDS)
+    assertEquals(listOf(true), results)
+  }
+
+  @Test fun resetTimeoutCompletesRatherThanLeavingUnpairWaitingForever() {
+    readyForReset()
+    val results = mutableListOf<Boolean>()
+    nimo.resetForUnpair { results.add(it) }
+    Shadows.shadowOf(Looper.getMainLooper()).idleFor(6, TimeUnit.SECONDS)
+    assertEquals(listOf(false), results)
+    respond(8, 3, 0)
+    assertEquals(listOf(false), results)
+  }
+
+  @Test fun passiveForgetNeverSendsFactoryReset() {
+    val frames = readyForReset()
+    nimo.forget()
+    assertTrue(frames.isEmpty())
+  }
+
+  @Test fun unbondTargetsOnlyTheSelectedNimo() {
+    val adapter = BluetoothAdapter.getDefaultAdapter()
+    val selected = adapter.getRemoteDevice("00:11:22:33:44:55")
+    val other = adapter.getRemoteDevice("00:11:22:33:44:66")
+    Shadows.shadowOf(selected).setCreatedBond(true)
+    Shadows.shadowOf(other).setCreatedBond(true)
+    Nimo.removeBluetoothBond(selected.address)
+    // Robolectric tracks removeBond through this flag, independently of bondState.
+    assertFalse(selected.createBond())
+    assertTrue(other.createBond())
+  }
+
+  private fun readyForReset(): MutableList<ByteArray> {
+    val frames = mutableListOf<ByteArray>()
+    val device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice("00:11:22:33:44:55")
+    val gatt = ShadowBluetoothGatt.newInstance(device)
+    setField("gatt", gatt)
+    setField("txChar", BluetoothGattCharacteristic(NimoBLE.CHAR_TX, 8, 16))
+    val state = Nimo::class.java.getDeclaredField("handshakeState")
+    setField("handshakeState", state.type.enumConstants.single { it.toString() == "READY" })
+    lateinit var queue: NimoGattQueue<BluetoothGattCharacteristic>
+    queue = NimoGattQueue(
+      NimoScheduler { delay, task ->
+        val handler = Handler(Looper.getMainLooper())
+        val pending = Runnable { task() }
+        handler.postDelayed(pending, delay)
+        val cancel: () -> Unit = { handler.removeCallbacks(pending) }
+        cancel
+      },
+      { characteristic, bytes ->
+        frames.add(bytes.copyOf())
+        Handler(Looper.getMainLooper()).post { queue.written(gatt, characteristic, true) }
+        true
+      },
+      { fail(it) },
+      NimoBLE.INTER_FRAME_DELAY_MS,
+    )
+    queue.connected(gatt)
+    setField("writes", queue)
+    return frames
+  }
+
+  private fun setField(name: String, value: Any) {
+    Nimo::class.java.getDeclaredField(name).apply { isAccessible = true }.set(nimo, value)
+  }
+
+  private fun respond(cmd: Int, key: Int, status: Int) {
+    Nimo::class.java.getDeclaredMethod("handleResponse", Int::class.javaPrimitiveType,
+      Int::class.javaPrimitiveType, Int::class.javaPrimitiveType, ByteArray::class.java)
+      .apply { isAccessible = true }.invoke(nimo, cmd, key, status, byteArrayOf())
+  }
+
+  private fun runOffMain(operation: () -> Unit) {
+    val failure = AtomicReference<Throwable?>()
+    val caller = Thread({
+      try {
+        operation()
+        // The manager may replace this instance immediately after return. An asynchronous
+        // post is insufficient: the old connection must already be completely torn down.
+        assertEquals(false, DeviceStore.get("glasses", "connected"))
+        assertEquals(false, DeviceStore.get("glasses", "fullyBooted"))
+        assertTrue(File(captureDirectory, "session.json").exists())
+      } catch (error: Throwable) { failure.set(error) }
+    }, "Expo-AsyncFunctionQueue-test")
+    caller.start()
+    // The Main looper is paused, so no teardown may have run on the Expo worker.
+    assertEquals(true, DeviceStore.get("glasses", "connected"))
+    assertEquals(true, DeviceStore.get("glasses", "fullyBooted"))
+    assertRememberedDevice()
+    assertTrue(context.unregisterLoopers.isEmpty())
+    assertTrue(storeLoopers.isEmpty())
+    assertTrue("Encoder stopped before Main processed teardown", encoderThread.isAlive)
+    assertFalse(File(captureDirectory, "session.json").exists())
+    val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5)
+    while (caller.isAlive && System.nanoTime() < deadline) {
+      Shadows.shadowOf(Looper.getMainLooper()).idle()
+      caller.join(10)
+    }
+    if (caller.isAlive) {
+      caller.interrupt()
+      caller.join(1_000)
+      fail("Lifecycle did not return after Main processed teardown")
+    }
+    failure.get()?.let { throw AssertionError("Off-main lifecycle entrypoint failed", it) }
+  }
+
+  private fun assertDisconnectedOnMain() {
+    assertEquals(false, DeviceStore.get("glasses", "connected"))
+    assertEquals(false, DeviceStore.get("glasses", "fullyBooted"))
+    assertEquals(ConnTypes.DISCONNECTED, DeviceStore.get("glasses", "connectionState"))
+    assertEquals(listOf(Looper.getMainLooper()), context.unregisterLoopers)
+    assertTrue(storeLoopers.isNotEmpty())
+    assertTrue(storeLoopers.all { it === Looper.getMainLooper() })
+    val receiptFile = File(captureDirectory, "session.json")
+    val beforeLateCallback = receiptFile.readText()
+    val receipt = JSONObject(beforeLateCallback)
+    assertFalse(receipt.getBoolean("ok"))
+    assertTrue(receipt.getString("error").contains("disconnected"))
+    writeCompleted()
+    Shadows.shadowOf(Looper.getMainLooper()).idle()
+    assertEquals(beforeLateCallback, receiptFile.readText())
+    assertEquals(1, writes)
+  }
+
+  private fun assertRememberedDevice() {
+    val prefs = context.getSharedPreferences("NimoPrefs", Context.MODE_PRIVATE)
+    assertEquals("00:11:22:33:44:55", prefs.getString("nimo_lastDeviceAddress", null))
+    assertEquals("Nimo-test", prefs.getString("nimo_lastDeviceName", null))
+  }
+}

package/android/src/testDebug/java/com/mentra/bluetoothsdk/sgcs/NimoReadinessDriverTest.kt

@@ -0,0 +1,205 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothGatt
+import android.bluetooth.BluetoothGattCallback
+import android.bluetooth.BluetoothGattCharacteristic
+import android.bluetooth.BluetoothGattService
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import androidx.test.core.app.ApplicationProvider
+import com.mentra.bluetoothsdk.Bridge
+import com.mentra.bluetoothsdk.DeviceManager
+import com.mentra.bluetoothsdk.DeviceStore
+import com.mentra.bluetoothsdk.utils.ConnTypes
+import java.util.UUID
+import org.junit.After
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.LooperMode
+import org.robolectric.shadows.ShadowBluetoothGatt
+
+/** Exercise real receive dispatch, not just the already-tested canvas state machine. */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+@LooperMode(LooperMode.Mode.PAUSED)
+@Suppress("deprecation")
+class NimoReadinessDriverTest {
+  private lateinit var nimo: Nimo
+  private lateinit var encoderThread: Thread
+  private lateinit var manager: DeviceManager
+  private var previousManager: DeviceManager? = null
+  private lateinit var callback: BluetoothGattCallback
+  private lateinit var currentGatt: BluetoothGatt
+  private lateinit var rx: BluetoothGattCharacteristic
+  private lateinit var canvas: NimoCanvasCoordinator
+  private val frames = mutableListOf<ByteArray>()
+  private val failures = mutableListOf<String>()
+  private val rejections = mutableListOf<Int>()
+  private val savedStore = mutableMapOf<String, Any>()
+
+  @Before fun setup() {
+    Bridge.initialize(ApplicationProvider.getApplicationContext<Context>())
+    manager = DeviceManager(initializeHardware = false)
+    DeviceManager::class.java.getDeclaredField("_instance").apply { isAccessible = true }.let {
+      previousManager = it.get(null) as DeviceManager?
+      it.set(null, manager)
+    }
+    for (key in listOf("connected", "fullyBooted", "connectionState", "headUp", "voiceActivityDetectionEnabled")) {
+      DeviceStore.get("glasses", key)?.let { savedStore[key] = it }
+    }
+    // Suppress unrelated manager side effects when finishHandshake republishes these values.
+    DeviceStore.set("glasses", "connected", true)
+    DeviceStore.set("glasses", "fullyBooted", true)
+    DeviceStore.set("glasses", "connectionState", ConnTypes.CONNECTED)
+    val before = Thread.getAllStackTraces().keys
+    nimo = Nimo()
+    encoderThread = Thread.getAllStackTraces().keys.single {
+      it.name == "NimoCanvasEncoder" && it !in before
+    }
+    callback = field("gattCallback").get(nimo) as BluetoothGattCallback
+    currentGatt = newGatt()
+    field("gatt").set(nimo, currentGatt)
+    rx = characteristic(NimoBLE.SERVICE_UUID)
+    val handler = Handler(Looper.getMainLooper())
+    canvas = NimoCanvasCoordinator(NimoScheduler { delay, task ->
+      val runnable = Runnable(task)
+      handler.postDelayed(runnable, delay)
+      ({ handler.removeCallbacks(runnable) })
+    }, { 512 }, { chain, started, completed ->
+      frames.addAll(chain.map { it.copyOf() })
+      started()
+      completed()
+      true
+    }, { failures.add(it) }, { rejections.add(it) })
+    field("canvas").set(nimo, canvas)
+  }
+
+  @After fun dispose() {
+    try {
+      nimo.cleanup()
+      idle()
+      encoderThread.join(1_000)
+      assertFalse("Encoder thread leaked", encoderThread.isAlive)
+    } finally {
+      manager.cleanup()
+      savedStore.forEach { (key, value) -> DeviceStore.set("glasses", key, value) }
+      DeviceManager::class.java.getDeclaredField("_instance").apply { isAccessible = true }
+        .set(null, previousManager)
+    }
+  }
+
+  @Test fun onlyCompleteSuccessfulHeartbeatReleasesNotReadyAndSendsLatestScene() {
+    val latest = byteArrayOf(1, 0, 1)
+    canvas.offer(byteArrayOf(0, 0, 1), "first")
+    finishHandshake(peer = true)
+    assertKeys(1)
+    emit(packet(7, 1, byteArrayOf(7)))
+    assertEquals(listOf(7), rejections)
+    canvas.offer(latest, "latest")
+
+    emit(packet(6, 3, byteArrayOf(0, 1))) // TWS alone cannot refresh peer readiness.
+    emit(heartbeat(status = 7))
+    emit(packet(6, 4, byteArrayOf(0, 3) + ByteArray(9))) // Missing slaveGatt.
+    val corrupt = heartbeat().also { it[it.lastIndex] = 2 } // Invalid CRC.
+    emit(corrupt)
+    assertKeys(1)
+
+    emit(heartbeat())
+    assertKeys(1, 1)
+    emit(heartbeat()) // No overlapping Launch while awaiting its ACK.
+    assertKeys(1, 1)
+    emit(packet(7, 1, byteArrayOf(0, 0xFD.toByte())))
+    assertKeys(1, 1, 4)
+    assertArrayEquals(NimoCanvasCodec.frames(4, latest, 512).single(), frames.last())
+    assertTrue(failures.isEmpty())
+  }
+
+  @Test fun freshHandshakeProbesCanvasWithoutWaitingForHeartbeat() {
+    finishHandshake(peer = null)
+    assertNull(field("peerCompanionReady").get(nimo))
+    assertKeys(1) // Firmware validates peer readiness, not a synthetic heartbeat.
+    emit(packet(6, 2, byteArrayOf(0, 0, 1))) // Stock dashboard entering at startup.
+    assertKeys(1)
+    emit(packet(7, 1, byteArrayOf(0, 0xFD.toByte())))
+    assertKeys(1, 4)
+    assertArrayEquals(NimoCanvasCodec.frames(4, byteArrayOf(0, 0, 1), 512).single(), frames.last())
+    assertTrue(failures.isEmpty())
+  }
+
+  @Test fun knownDisconnectedPeerStillBlocksUntilReadinessArrives() {
+    finishHandshake(peer = false)
+    assertKeys()
+    emit(packet(6, 3, byteArrayOf(0, 1)))
+    assertKeys()
+    emit(heartbeat())
+    assertKeys(1)
+    assertTrue(failures.isEmpty())
+  }
+
+  @Test fun queuedOldGattAndWrongServiceCannotEstablishReadiness() {
+    canvas.offer(byteArrayOf(0, 0, 1), "initial")
+    finishHandshake(peer = false)
+    val oldGatt = currentGatt
+    queue(heartbeat(), oldGatt)
+    currentGatt = newGatt()
+    field("gatt").set(nimo, currentGatt)
+    idle() // The generation check must occur when the queued callback executes.
+    emit(heartbeat(), oldGatt)
+    emit(heartbeat(), currentGatt, characteristic(UUID.fromString("00001234-0000-1000-8000-00805f9b34fb")))
+    assertEquals(false, field("peerCompanionReady").get(nimo))
+    assertKeys()
+
+    emit(heartbeat()) // Positive control through the actual current RX callback.
+    assertKeys(1)
+    oldGatt.close()
+    assertTrue(failures.isEmpty())
+  }
+
+  private fun finishHandshake(peer: Boolean?) {
+    field("twsConnected").set(nimo, true)
+    field("peerCompanionReady").set(nimo, peer)
+    Nimo::class.java.getDeclaredMethod("finishHandshake").apply { isAccessible = true }.invoke(nimo)
+    idle()
+  }
+
+  private fun newGatt(): BluetoothGatt = ShadowBluetoothGatt.newInstance(
+    BluetoothAdapter.getDefaultAdapter().getRemoteDevice("00:11:22:33:44:55"),
+  )
+
+  private fun characteristic(serviceId: UUID): BluetoothGattCharacteristic {
+    val characteristic = BluetoothGattCharacteristic(NimoBLE.CHAR_RX,
+      BluetoothGattCharacteristic.PROPERTY_NOTIFY, BluetoothGattCharacteristic.PERMISSION_READ)
+    BluetoothGattService(serviceId, BluetoothGattService.SERVICE_TYPE_PRIMARY).addCharacteristic(characteristic)
+    return characteristic
+  }
+
+  private fun heartbeat(status: Int = 0, peer: Int = 1) = packet(6, 4,
+    byteArrayOf(status.toByte(), 3) + ByteArray(8) + byteArrayOf(1, peer.toByte()))
+
+  private fun packet(command: Int, key: Int, payload: ByteArray) =
+    NimoFrameCodec.encodeFrame(command, key, payload, needsAck = false)
+
+  private fun queue(packet: ByteArray, gatt: BluetoothGatt = currentGatt,
+                    characteristic: BluetoothGattCharacteristic = rx) {
+    characteristic.value = packet.copyOf()
+    callback.onCharacteristicChanged(gatt, characteristic)
+  }
+
+  private fun emit(packet: ByteArray, gatt: BluetoothGatt = currentGatt,
+                   characteristic: BluetoothGattCharacteristic = rx) {
+    queue(packet, gatt, characteristic)
+    idle()
+  }
+
+  private fun idle() = Shadows.shadowOf(Looper.getMainLooper()).idle()
+  private fun field(name: String) = Nimo::class.java.getDeclaredField(name).apply { isAccessible = true }
+  private fun assertKeys(vararg expected: Int) =
+    assertEquals(expected.toList(), frames.map { it[9].toInt() and 255 })
+}

package/build/BluetoothSdk.types.d.ts

@@ -444,6 +444,15 @@ export type WearTuning = {
 export type WearStateEvent = {
     type: "wear_state";
     worn: boolean;
+    /** Unworn countdown, present on firmware that reports it. Milliseconds. */
+    elapsedMs?: number;
+    timeoutMs?: number;
+    /** cs_swit type 11. Absent on older firmware. */
+    enabled?: boolean;
+    /** Countdown is running (glasses are off the face and the feature is on). */
+    armed?: boolean;
+    /** Clock is running, but charging, a call, OTA, or factory test is holding shutdown. */
+    inhibited?: boolean;
 };
 /**
  * What the wear poll loop is actually running. A rejected patch echoes the
@@ -1204,6 +1213,7 @@ export interface BluetoothSdkPublicModule {
     setGalleryModeEnabled(enabled: boolean): Promise<SettingsAckSuccessEvent>;
     setVoiceActivityDetectionEnabled(enabled: boolean): Promise<void>;
     setLoudnessGateEnabled(enabled: boolean): Promise<void>;
+    setAutoPowerOffEnabled(enabled: boolean): Promise<void>;
     /**
      * @deprecated Sticky action-button photo presets are deprecated. Prefer per-request
      * `requestPhoto(...)` options (e.g. `mode: "text"` for text sensor size/crop, or explicit per-shot
@@ -1331,6 +1341,8 @@ export interface OtaProgress {
     errorMessage?: string;
 }
 export interface GlassesStatus {
+    /** iOS G2 arm still disconnected after a three-second partial link; cleared on reset or both links. */
+    g2MissingArm?: "left" | "right" | null;
     connection: GlassesConnectionStatus;
     micEnabled: boolean;
     voiceActivityDetectionEnabled: boolean;
@@ -1505,6 +1517,7 @@ export type BluetoothSettingsUpdate = Partial<{
     gallery_mode: boolean;
     voice_activity_detection_enabled: boolean;
     loudness_gate_enabled: boolean;
+    auto_power_off_enabled: boolean;
     /** Effective mic tuning only. `{}` means "reset to firmware defaults". */
     mic_tuning: MicTuning;
     button_photo_size: ButtonPhotoSize;