@mentra/bluetooth-sdk 0.1.19 → 0.1.21-beta.0

package/android/src/main/java/com/mentra/bluetoothsdk/utils/audio/PcmStreamPlayer.kt

@@ -0,0 +1,328 @@
+package com.mentra.bluetoothsdk.utils.audio
+
+import android.media.AudioAttributes
+import android.media.AudioFormat
+import android.media.AudioTrack
+import android.util.Base64
+import android.util.Log
+import java.util.ArrayDeque
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+import kotlin.math.max
+
+/**
+ * Live PCM chunk player for miniapp `speaker.createStream()`.
+ *
+ * One instance = one stream session. 16-bit LE PCM only. Unlike the SCO-tuned
+ * [PCMAudioPlayer], this uses USAGE_MEDIA so the OS routes it like any media
+ * playback (A2DP to connected glasses, else phone speaker).
+ *
+ * Threading: a dedicated feeder thread drains an in-memory chunk queue into a
+ * MODE_STREAM AudioTrack (AudioTrack.write blocks there, not on callers).
+ * `write` blocks the CALLING thread only while the backlog exceeds
+ * [BACKPRESSURE_CEILING_MS] — call it from a background dispatcher. When the
+ * track underruns (queue empty), AudioTrack plays silence and playback resumes
+ * seamlessly on the next chunk; no stop/start pops.
+ */
+class PcmStreamPlayer(
+        private val streamId: String,
+        private val sampleRate: Int,
+        channels: Int,
+        volume: Float,
+) {
+    companion object {
+        private const val TAG = "PcmStreamPlayer"
+
+        /** write() blocks while more than this is queued but unplayed. */
+        private const val BACKPRESSURE_CEILING_MS = 2_000L
+
+        /** Hard cap — writes that would exceed this are rejected outright. */
+        private const val MAX_BACKLOG_MS = 10_000L
+
+        /** AudioTrack buffer: max(4x minimum, 500ms) of jitter headroom. */
+        private const val TRACK_BUFFER_MS = 500
+    }
+
+    private val bytesPerFrame = 2 * channels
+    private val channelMask =
+            if (channels >= 2) AudioFormat.CHANNEL_OUT_STEREO else AudioFormat.CHANNEL_OUT_MONO
+
+    private val lock = ReentrantLock()
+    private val queueChanged = lock.newCondition()
+
+    /** Pending chunks not yet handed to AudioTrack. Guarded by [lock]. */
+    private val queue = ArrayDeque<ByteArray>()
+    private var queuedBytes = 0L
+
+    /** Total frames handed to AudioTrack.write. Guarded by [lock]. */
+    private var framesWritten = 0L
+
+    private var closing = false
+    private var aborted = false
+    private var writeInProgress = false
+    private var released = false
+    private var finalPlayedFrames: Long? = null
+    private var endedError: String? = null
+
+    private val audioTrack: AudioTrack
+    private val feeder: Thread
+
+    init {
+        val minBuf =
+                AudioTrack.getMinBufferSize(sampleRate, channelMask, AudioFormat.ENCODING_PCM_16BIT)
+        val jitterBuf = sampleRate * bytesPerFrame * TRACK_BUFFER_MS / 1000
+        audioTrack =
+                AudioTrack.Builder()
+                        .setAudioAttributes(
+                                AudioAttributes.Builder()
+                                        .setUsage(AudioAttributes.USAGE_MEDIA)
+                                        .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                                        .build()
+                        )
+                        .setAudioFormat(
+                                AudioFormat.Builder()
+                                        .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
+                                        .setSampleRate(sampleRate)
+                                        .setChannelMask(channelMask)
+                                        .build()
+                        )
+                        .setBufferSizeInBytes(max(minBuf * 4, jitterBuf))
+                        .setTransferMode(AudioTrack.MODE_STREAM)
+                        .build()
+        if (audioTrack.state != AudioTrack.STATE_INITIALIZED) {
+            audioTrack.release()
+            throw IllegalStateException("AudioTrack failed to initialize (rate=$sampleRate)")
+        }
+        audioTrack.setVolume(volume.coerceIn(0f, 1f))
+        audioTrack.play()
+
+        feeder =
+                Thread({ feedLoop() }, "PcmStreamPlayer-$streamId").apply {
+                    isDaemon = true
+                    start()
+                }
+        Log.d(TAG, "[$streamId] opened: rate=$sampleRate ch=$channels vol=$volume")
+    }
+
+    /** Milliseconds of audio accepted but not yet played out. */
+    private fun backlogMsLocked(): Long {
+        val playedFrames = audioTrack.playbackHeadPosition.toLong() and 0xFFFFFFFFL
+        val queuedFrames = queuedBytes / bytesPerFrame
+        return max(0L, (framesWritten - playedFrames + queuedFrames)) * 1000L / sampleRate
+    }
+
+    /**
+     * Append base64-encoded 16-bit LE PCM. Blocks while the backlog is above
+     * the backpressure ceiling. Returns the backlog in ms after this chunk.
+     */
+    fun write(base64: String): Long {
+        val bytes = Base64.decode(base64, Base64.DEFAULT)
+        require(bytes.isNotEmpty()) { "PCM chunk is empty" }
+        require(bytes.size % bytesPerFrame == 0) {
+            "PCM chunk length ${bytes.size} is not aligned to a $bytesPerFrame-byte frame"
+        }
+        lock.withLock {
+            check(!closing && !aborted) { "stream is closed" }
+            endedError?.let { throw IllegalStateException(it) }
+            check(backlogMsLocked() + bytes.size / bytesPerFrame * 1000L / sampleRate <= MAX_BACKLOG_MS) {
+                "backlog exceeds ${MAX_BACKLOG_MS}ms — producer is not throttling"
+            }
+            queue.add(bytes)
+            queuedBytes += bytes.size
+            queueChanged.signalAll()
+            // Backpressure: hold the caller until the feeder drains below the
+            // ceiling. Caller is a background dispatcher, never the UI thread.
+            while (backlogMsLocked() > BACKPRESSURE_CEILING_MS && !closing && !aborted && endedError == null) {
+                queueChanged.await()
+            }
+            endedError?.let { throw IllegalStateException(it) }
+            return backlogMsLocked()
+        }
+    }
+
+    /**
+     * Drain everything queued, then stop. Blocks until played out. Returns the
+     * total played duration in ms.
+     */
+    fun close(): Long {
+        lock.withLock {
+            if (aborted) return playedMsLocked()
+            closing = true
+            queueChanged.signalAll()
+            // Wait for the feeder to hand everything to the track...
+            while ((queue.isNotEmpty() || writeInProgress) && endedError == null && !aborted) {
+                queueChanged.await()
+            }
+        }
+        // ...then for the track to play it out while AudioTrack is still in
+        // PLAYSTATE_PLAYING. Calling stop() first flushes pending MODE_STREAM
+        // audio on several Android builds and truncates the final chunk.
+        try {
+            val deadline = System.currentTimeMillis() + MAX_BACKLOG_MS
+            while (System.currentTimeMillis() < deadline) {
+                val drained =
+                        lock.withLock {
+                            val played = audioTrack.playbackHeadPosition.toLong() and 0xFFFFFFFFL
+                            played >= framesWritten || endedError != null
+                        }
+                if (drained) break
+                Thread.sleep(20)
+            }
+            audioTrack.stop()
+        } catch (e: Exception) {
+            Log.w(TAG, "[$streamId] drain-on-close failed", e)
+        } finally {
+            releaseInternals()
+        }
+        return playedMsLocked()
+    }
+
+    /** Stop now, dropping the backlog. Idempotent. */
+    fun abort() {
+        lock.withLock {
+            if (aborted) return
+            aborted = true
+            queue.clear()
+            queuedBytes = 0
+            queueChanged.signalAll()
+        }
+        try {
+            audioTrack.pause()
+            audioTrack.flush()
+        } catch (e: Exception) {
+            Log.w(TAG, "[$streamId] abort flush failed", e)
+        }
+        releaseInternals()
+        Log.d(TAG, "[$streamId] aborted")
+    }
+
+    /** Played duration so far, in ms. */
+    fun playedMs(): Long = lock.withLock { playedMsLocked() }
+
+    private fun playedMsLocked(): Long {
+        val played =
+                finalPlayedFrames
+                        ?: try {
+                            audioTrack.playbackHeadPosition.toLong() and 0xFFFFFFFFL
+                        } catch (e: Exception) {
+                            framesWritten
+                        }
+        return played * 1000L / sampleRate
+    }
+
+    private fun feedLoop() {
+        try {
+            while (true) {
+                val chunk: ByteArray =
+                        lock.withLock {
+                            while (queue.isEmpty() && !closing && !aborted) {
+                                queueChanged.await()
+                            }
+                            if (aborted) return
+                            if (queue.isEmpty() && closing) return
+                            queue.poll()!!.also { writeInProgress = true }
+                        }
+                // Blocking write OUTSIDE the lock so write()/abort() stay responsive.
+                var off = 0
+                while (off < chunk.size) {
+                    val n = audioTrack.write(chunk, off, chunk.size - off)
+                    if (n < 0) throw IllegalStateException("AudioTrack.write error $n")
+                    off += n
+                }
+                lock.withLock {
+                    queuedBytes -= chunk.size
+                    framesWritten += chunk.size / bytesPerFrame
+                    writeInProgress = false
+                    queueChanged.signalAll()
+                }
+            }
+        } catch (e: Exception) {
+            if (!aborted) {
+                Log.e(TAG, "[$streamId] feeder failed", e)
+                lock.withLock {
+                    endedError = e.message ?: "feeder failed"
+                    queue.clear()
+                    queuedBytes = 0
+                    writeInProgress = false
+                    queueChanged.signalAll()
+                }
+            }
+        } finally {
+            lock.withLock { queueChanged.signalAll() }
+        }
+    }
+
+    private fun releaseInternals() {
+        val shouldRelease =
+                lock.withLock {
+                    if (released) {
+                        false
+                    } else {
+                        finalPlayedFrames =
+                                try {
+                                    audioTrack.playbackHeadPosition.toLong() and 0xFFFFFFFFL
+                                } catch (_: Exception) {
+                                    framesWritten
+                                }
+                        released = true
+                        true
+                    }
+                }
+        if (!shouldRelease) return
+        try {
+            audioTrack.release()
+        } catch (e: Exception) {
+            Log.w(TAG, "[$streamId] release failed", e)
+        }
+    }
+}
+
+/**
+ * Registry of active [PcmStreamPlayer] sessions, keyed by streamId. All
+ * methods are safe to call with unknown ids (write throws, abort no-ops) so
+ * races with teardown resolve cleanly.
+ */
+object PcmStreamManager {
+    private val players = java.util.concurrent.ConcurrentHashMap<String, PcmStreamPlayer>()
+
+    fun open(streamId: String, sampleRate: Int, channels: Int, volume: Float) {
+        require(streamId.isNotBlank()) { "streamId is required" }
+        require(sampleRate == 16000 || sampleRate == 24000 || sampleRate == 48000) {
+            "unsupported PCM sample rate $sampleRate"
+        }
+        require(channels == 1) { "only mono PCM is supported" }
+        // Replacing an id is a caller bug, but never leak the old track.
+        players.remove(streamId)?.abort()
+        players[streamId] = PcmStreamPlayer(streamId, sampleRate, channels, volume)
+    }
+
+    fun write(streamId: String, base64: String): Long {
+        val player =
+                players[streamId] ?: throw IllegalStateException("pcm stream $streamId is not open")
+        return player.write(base64)
+    }
+
+    fun close(streamId: String): Long {
+        val player =
+                players[streamId]
+                        ?: throw IllegalStateException("pcm stream $streamId is not open")
+        return try {
+            player.close()
+        } finally {
+            // Leave a draining player addressable so teardown can still abort
+            // it. The conditional remove preserves a replacement with the
+            // same id if one was opened while this close was completing.
+            players.remove(streamId, player)
+        }
+    }
+
+    fun abort(streamId: String) {
+        players.remove(streamId)?.abort()
+    }
+
+    fun abortAll() {
+        val active = players.values.toList()
+        players.clear()
+        active.forEach { it.abort() }
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.mentra.bluetoothsdk
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class BluetoothSdkExceptionTest {
+    @Test
+    fun `exception is usable without the Expo runtime`() {
+        val cause = IllegalArgumentException("cause")
+        val error = BluetoothSdkException("capture_failed", "Capture failed", cause)
+
+        assertThat(error.code).isEqualTo("capture_failed")
+        assertThat(error.message).isEqualTo("Capture failed")
+        assertThat(error.cause).isSameAs(cause)
+        assertThat(error).isInstanceOf(IllegalStateException::class.java)
+        assertThat(error.javaClass.superclass.name).doesNotStartWith("expo.modules")
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/camera/PhotoRequestTest.kt

@@ -1,6 +1,7 @@
 package com.mentra.bluetoothsdk.camera
 
 import com.mentra.bluetoothsdk.PhotoCompression
+import com.mentra.bluetoothsdk.PhotoMode
 import com.mentra.bluetoothsdk.PhotoRequest
 import com.mentra.bluetoothsdk.PhotoSize
 import org.assertj.core.api.Assertions.assertThat
@@ -34,6 +35,8 @@ class PhotoRequestTest {
             )
 
         assertThat(request.exposureTimeNs).isNull()
+        assertThat(request.mode).isEqualTo(PhotoMode.PHOTO)
+        assertThat(request.transferMethod).isEqualTo("auto")
     }
 
     @Test
@@ -77,4 +80,32 @@ class PhotoRequestTest {
 
         assertThat(request.requestId).isEqualTo("photo-1")
     }
+
+    @Test
+    fun `fromMap preserves text mode`() {
+        val request =
+            PhotoRequest.fromMap(
+                mapOf(
+                    "size" to "medium",
+                    "mode" to "text",
+                    "webhookUrl" to "https://example.com/upload",
+                )
+            )
+
+        assertThat(request.mode).isEqualTo(PhotoMode.TEXT)
+    }
+
+    @Test
+    fun `fromMap preserves forced BLE transfer`() {
+        val request =
+            PhotoRequest.fromMap(
+                mapOf(
+                    "size" to "medium",
+                    "transferMethod" to "ble",
+                    "webhookUrl" to "https://example.com/upload",
+                )
+            )
+
+        assertThat(request.transferMethod).isEqualTo("ble")
+    }
 }

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/G1TextSanitizerTest.kt

@@ -0,0 +1,31 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class G1TextSanitizerTest {
+
+    @Test
+    fun `strips Vietnamese diacritics unsupported by G1`() {
+        assertThat(sanitizeG1DisplayText("Tiếng Việt: Đặng, Nguyễn, phở bò"))
+            .isEqualTo("Tieng Viet: Dang, Nguyen, pho bo")
+    }
+
+    @Test
+    fun `handles decomposed marks and preserves layout`() {
+        assertThat(sanitizeG1DisplayText("Cafe\u0301\nĐa Nang"))
+            .isEqualTo("Cafe\nDa Nang")
+    }
+
+    @Test
+    fun `expands Latin letters that do not decompose into combining marks`() {
+        assertThat(sanitizeG1DisplayText("Øresund Łódź Æsir Œuvre Straße Ðingvellir Þingvellir"))
+            .isEqualTo("Oresund Lodz AEsir OEuvre Strasse Dingvellir THingvellir")
+    }
+
+    @Test
+    fun `leaves text without diacritics unchanged`() {
+        assertThat(sanitizeG1DisplayText("Hello, world! 123"))
+            .isEqualTo("Hello, world! 123")
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/utils/BlePhotoUploadServiceTest.java

@@ -57,6 +57,15 @@ public class BlePhotoUploadServiceTest {
         assertThat(new JSONObject(json).getInt("sampleCount")).isEqualTo(5);
     }
 
+    @Test
+    public void convertToJpeg_passesThroughExistingJpegWithoutReencode() throws Exception {
+        File input = tempFolder.newFile("input.jpg");
+        writeMinimalJpeg(input);
+        byte[] inputBytes = java.nio.file.Files.readAllBytes(input.toPath());
+        byte[] outputBytes = BlePhotoUploadService.convertToJpegPreservingExif(inputBytes);
+        assertThat(outputBytes).isEqualTo(inputBytes);
+    }
+
     @Test
     public void convertToJpegPreservesUserComment() throws Exception {
         File input = tempFolder.newFile("input.jpg");

package/build/BluetoothSdk.types.d.ts

@@ -88,6 +88,16 @@ export type ConnectedWifiStatus = Extract<WifiStatus, {
 export declare function isConnectedWifiStatus(status: WifiStatus): status is ConnectedWifiStatus;
 export type WifiStatusChangeEvent = WifiStatus & {
     type: "wifi_status_change";
+    /**
+     * Glasses-reported provisioning failure reason when THIS event is the verdict of a
+     * failed connect attempt; absent on routine link-state updates. An attempt property,
+     * not a link property — which is why it lives on the event, not on WifiStatus:
+     * "connect_timeout" arrives on a disconnected status (never associated), while
+     * "connected_to_other_network" arrives on a *connected* status (the attempt failed
+     * and the glasses ended up on / fell back to a different SSID than requested).
+     * Requires ASG client v40+ — older glasses never send it.
+     */
+    error?: string;
 };
 export type HotspotStatus = {
     state: "disabled";
@@ -317,7 +327,7 @@ export type RgbLedControlSuccessResponseEvent = Extract<RgbLedControlResponseEve
     state: "success";
 }>;
 export type SettingsAckStatus = "applied" | "ready" | "error" | "failed" | "failure" | "rejected";
-export type SettingsAckSetting = "gallery_mode" | "button_photo" | "button_video_recording" | "button_max_recording_time" | "camera_fov" | "camera_tuning";
+export type SettingsAckSetting = "gallery_mode" | "button_photo" | "button_video_recording" | "button_max_recording_time" | "camera_fov" | "camera_fov_override" | "camera_tuning";
 export type SettingsAckEvent = {
     type: "settings_ack";
     requestId: string;
@@ -327,6 +337,7 @@ export type SettingsAckEvent = {
     fov?: number;
     roiPosition?: CameraRoiPositionValue;
     hardwareApplied?: boolean;
+    leaseId?: string;
     active?: boolean;
     size?: ButtonPhotoSize | string;
     width?: number;
@@ -348,7 +359,13 @@ export type SettingsAckSuccessEvent = Omit<SettingsAckEvent, "status"> & {
 export type RgbLedAction = "on" | "off";
 export type RgbLedColor = "red" | "green" | "blue" | "orange" | "white";
 export type PhotoSize = "low" | "medium" | "high" | "max";
+export type PhotoMode = "photo" | "text";
 export type ButtonPhotoSize = "low" | "medium" | "high" | "max";
+/**
+ * @deprecated Sticky action-button photo presets via {@link BluetoothSdkPublicModule.setPhotoCaptureDefaults}
+ * are deprecated. Prefer per-request {@link BluetoothSdkPublicModule.requestPhoto} options
+ * (e.g. `mode: "text"` for AE ÷3) instead of persisting button-photo tuning on the glasses.
+ */
 export type PhotoCaptureDefaults = {
     size?: PhotoSize;
     mfnr?: boolean;
@@ -423,6 +440,12 @@ export type CameraFovResult = {
     roiPosition: CameraRoiPosition;
     timestamp: number;
 };
+export type CameraFovOverrideRequest = CameraFovRequest & {
+    /** Phone-owned lease used to make delayed releases safe. */
+    leaseId: string;
+    /** Safety TTL; refresh the same lease/configuration to extend without a HAL restart. */
+    ttlMs?: number;
+};
 export type CameraFovSetting = {
     fov: number;
     roiPosition: CameraRoiPositionValue;
@@ -437,6 +460,9 @@ export type PhotoRequestParams = {
     requestId?: string;
     appId?: string;
     size: PhotoSize;
+    mode?: PhotoMode;
+    /** `ble` skips direct upload and forces phone-relayed BLE image transfer. */
+    transferMethod?: "auto" | "ble";
     webhookUrl: string | null;
     authToken: string | null;
     compress: PhotoCompression;
@@ -458,9 +484,12 @@ export type PhotoRequestParams = {
     ispAnalogGain?: string;
 };
 export type WarmUpCameraParams = {
+    /** Supply this when the owner needs to call stopCameraWarmUp during teardown. */
     requestId?: string;
     size: PhotoSize;
+    mode?: PhotoMode;
     exposureTimeNs?: number | null;
+    /** Ready-state hold; defaults to 15 seconds and is capped at 60 seconds by ASG. */
     durationMs?: number;
 };
 export type StreamVideoConfig = {
@@ -566,11 +595,24 @@ export type StreamResolvedConfig = {
         noiseSuppression?: boolean;
     };
 };
+/** Live encoder telemetry, when the glasses emit it (no firmware does yet). */
+export type StreamLiveStats = {
+    /** Current encoded video bitrate in bits per second. */
+    bitrate?: number;
+    /** Current encode frame rate. */
+    fps?: number;
+    droppedFrames?: number;
+    /** Seconds since the stream started. */
+    duration?: number;
+    /** Device temperature in °C, if the hardware reports it. */
+    temperatureC?: number;
+};
 type StreamStatusCommon = {
     type: "stream_status";
     streamId?: string;
     timestamp?: number;
     resolvedConfig?: StreamResolvedConfig;
+    stats?: StreamLiveStats;
 };
 export type StreamStatusEvent = (StreamStatusCommon & {
     kind: "lifecycle";
@@ -675,6 +717,8 @@ export type BluetoothSdkModuleEvents = {
     speaking_status: (event: SpeakingStatusEvent) => void;
     battery_status: (event: BatteryStatusEvent) => void;
     local_transcription: (event: LocalTranscriptionEvent) => void;
+    phone_notification: (event: PhoneNotificationEvent) => void;
+    phone_notification_dismissed: (event: PhoneNotificationDismissedEvent) => void;
     wifi_status_change: (event: WifiStatusChangeEvent) => void;
     wifi_scan_result: (event: WifiScanResultEvent) => void;
     hotspot_status_change: (event: HotspotStatusChangeEvent) => void;
@@ -719,6 +763,21 @@ export interface ExtractionProgressEvent {
     bytesRead: number;
     totalBytes: number;
 }
+export interface PhoneNotificationEvent {
+    notificationId: string;
+    app: string;
+    title: string;
+    content: string;
+    priority: string;
+    timestamp: number;
+    packageName: string;
+}
+export interface PhoneNotificationDismissedEvent {
+    notificationId: string;
+    notificationKey: string;
+    packageName: string;
+    timestamp: number;
+}
 export type PublicGlassesStatus = Omit<GlassesStatus, "otaUpdateAvailable" | "otaProgress" | "otaInProgress" | "otaVersionUrl">;
 export type PublicBluetoothStatus = Pick<BluetoothStatus, "searching" | "searchingController" | "systemMicUnavailable" | "micRanking" | "currentMic" | "searchResults" | "wifiScanResults" | "lastLog" | "otherBtConnected" | "galleryModeEnabled">;
 export type BluetoothSdkEventMap = {
@@ -798,10 +857,19 @@ export interface BluetoothSdkPublicModule {
     setHotspotState(enabled: boolean): Promise<HotspotStatusChangeEvent>;
     setGalleryModeEnabled(enabled: boolean): Promise<SettingsAckSuccessEvent>;
     setVoiceActivityDetectionEnabled(enabled: boolean): Promise<void>;
+    /**
+     * @deprecated Sticky action-button photo presets are deprecated. Prefer per-request
+     * `requestPhoto(...)` options (e.g. `mode: "text"` for AE ÷3, or explicit per-shot
+     * fields). Still functional until removed in a future release.
+     */
     setPhotoCaptureDefaults(settings: PhotoCaptureDefaults): Promise<SettingsAckSuccessEvent>;
     setVideoRecordingDefaults(settings: VideoRecordingDefaults): Promise<SettingsAckSuccessEvent>;
     setMaxVideoRecordingDuration(minutes: number): Promise<SettingsAckSuccessEvent>;
     setCameraFov(request: CameraFovRequest): Promise<CameraFovResult>;
+    /** One-way FOV command for legacy ASG clients that do not send settings acknowledgements. */
+    setLegacyCameraFov(request: CameraFovRequest): Promise<CameraFovResult>;
+    setCameraFovOverride(request: CameraFovOverrideRequest): Promise<CameraFovResult>;
+    releaseCameraFovOverride(leaseId: string): Promise<SettingsAckSuccessEvent>;
     /**
      * Configure camera HAL tuning (ANR / gain) on Mentra Live glasses.
      *
@@ -819,6 +887,8 @@ export interface BluetoothSdkPublicModule {
     queryGalleryStatus(): Promise<GalleryStatusEvent>;
     requestPhoto(params: PhotoRequestParams): Promise<PhotoSuccessResponseEvent>;
     warmUpCamera(params: WarmUpCameraParams): Promise<CameraStatusEvent>;
+    /** Release one request-owned warm-up. Opening requests reject with camera_warm_up_cancelled. */
+    stopCameraWarmUp(requestId: string): Promise<void>;
     startVideoRecording(requestId: string, save: boolean, sound: boolean, settings?: VideoRecordingSettings): Promise<VideoRecordingStartedStatusEvent>;
     /**
      * Stop the active recording. When {@link webhookUrl} is provided, the glasses