@mentra/bluetooth-sdk 0.1.6 → 0.1.8

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

@@ -66,6 +66,7 @@ object DeviceStore {
         store.set("glasses", "deviceModel", "")
         store.set("glasses", "firmwareVersion", "")
         store.set("glasses", "micEnabled", false)
+        store.set("glasses", "voiceActivityDetectionEnabled", true)
         store.set("glasses", "bluetoothClassicConnected", false)
         store.set("glasses", "caseRemoved", true)
         store.set("glasses", "caseOpen", true)
@@ -121,12 +122,13 @@ object DeviceStore {
         store.set("bluetooth", "dashboard_depth", 2)
         store.set("bluetooth", "head_up_angle", 30)
         store.set("bluetooth", "contextual_dashboard", true)
-        store.set("bluetooth", "galleryModeAuto", true)
+        store.set("bluetooth", "gallery_mode", true)
+        store.set("bluetooth", "voice_activity_detection_enabled", true)
         store.set("bluetooth", "screen_disabled", false)
         store.set("bluetooth", "button_photo_size", "medium")
         store.set("bluetooth", "button_camera_led", true)
         store.set("bluetooth", "button_max_recording_time", 10)
-        store.set("bluetooth", "camera_fov", mapOf("fov" to 118, "roiPosition" to 0))
+        store.set("bluetooth", "camera_fov", mapOf("fov" to 118, "roi_position" to 0))
         store.set("bluetooth", "button_video_width", 1280)
         store.set("bluetooth", "button_video_height", 720)
         store.set("bluetooth", "button_video_fps", 30)
@@ -137,7 +139,6 @@ object DeviceStore {
         store.set("bluetooth", "should_send_pcm", false)
         store.set("bluetooth", "should_send_lc3", false)
         store.set("bluetooth", "should_send_transcript", false)
-        store.set("bluetooth", "bypass_vad", true)
         store.set("bluetooth", "use_native_dashboard", false)
     }
 
@@ -240,9 +241,12 @@ object DeviceStore {
                     DeviceManager.getInstance().sgc?.setDashboardMenu(items)
                 }
             }
-            "bluetooth" to "galleryModeAuto" -> {
+            "bluetooth" to "gallery_mode" -> {
                 DeviceManager.getInstance().sgc?.sendGalleryMode()
             }
+            "bluetooth" to "voice_activity_detection_enabled" -> {
+                DeviceManager.getInstance().sgc?.sendVoiceActivityDetectionSetting()
+            }
             "bluetooth" to "screen_disabled" -> {
                 (value as? Boolean)?.let { disabled ->
                     if (disabled) {

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

@@ -7,6 +7,7 @@ import android.os.Looper
 import com.mentra.bluetoothsdk.utils.ControllerTypes
 import com.mentra.bluetoothsdk.utils.PhoneAudioMonitor
 import java.util.Collections
+import java.util.UUID
 import java.util.concurrent.atomic.AtomicBoolean
 
 class MentraBluetoothSdk private constructor(
@@ -23,6 +24,8 @@ class MentraBluetoothSdk private constructor(
     private val bridgeEventSinkId: String
     private val storeListenerId: String
     private var suppressDefaultDeviceEvents = false
+    private val streamKeepAliveLock = Any()
+    private var activeStreamKeepAlive: ActiveStreamKeepAlive? = null
 
     init {
         listeners.add(listener)
@@ -36,6 +39,8 @@ class MentraBluetoothSdk private constructor(
         private val DEFAULT_DEVICE_KEYS = setOf("default_wearable", "device_name", "device_address")
         private val SCAN_STATE_KEYS = setOf("searching", "searchingController", "searchResults")
         private const val DEFAULT_SCAN_TIMEOUT_MS = 15_000L
+        private const val DEFAULT_STREAM_KEEP_ALIVE_INTERVAL_SECONDS = 5
+        private const val MAX_MISSED_STREAM_KEEP_ALIVE_ACKS = 3
 
         @JvmStatic
         fun create(
@@ -51,6 +56,14 @@ class MentraBluetoothSdk private constructor(
         ): MentraBluetoothSdk = MentraBluetoothSdk(context, config, listener)
     }
 
+    private data class ActiveStreamKeepAlive(
+        val streamId: String,
+        val intervalMs: Long,
+        var pendingAckId: String? = null,
+        var missedAckCount: Int = 0,
+        var nextTick: Runnable? = null,
+    )
+
     fun addListener(listener: MentraBluetoothSdkListener) {
         listeners.add(listener)
     }
@@ -308,8 +321,12 @@ class MentraBluetoothSdk private constructor(
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "screen_disabled", disabled)
     }
 
-    fun setGalleryMode(mode: GalleryMode) {
-        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "galleryModeAuto", mode == GalleryMode.AUTO)
+    fun setGalleryModeEnabled(enabled: Boolean) {
+        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "gallery_mode", enabled)
+    }
+
+    fun setVoiceActivityDetectionEnabled(enabled: Boolean) {
+        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "voice_activity_detection_enabled", enabled)
     }
 
     fun setButtonPhotoSettings(size: ButtonPhotoSize) {
@@ -320,14 +337,14 @@ class MentraBluetoothSdk private constructor(
         setButtonPhotoSettings(size = settings.size)
     }
 
-    fun setButtonVideoRecordingSettings(width: Int, height: Int, frameRate: Int) {
+    fun setButtonVideoRecordingSettings(width: Int, height: Int, fps: Int) {
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "button_video_width", width)
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "button_video_height", height)
-        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "button_video_fps", frameRate)
+        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "button_video_fps", fps)
     }
 
     fun setButtonVideoRecordingSettings(settings: ButtonVideoRecordingSettings) {
-        setButtonVideoRecordingSettings(width = settings.width, height = settings.height, frameRate = settings.frameRate)
+        setButtonVideoRecordingSettings(width = settings.width, height = settings.height, fps = settings.fps)
     }
 
     fun setButtonCameraLed(enabled: Boolean) {
@@ -342,14 +359,13 @@ class MentraBluetoothSdk private constructor(
         DeviceStore.apply(
             ObservableStore.BLUETOOTH_CATEGORY,
             "camera_fov",
-            mapOf("fov" to fov.fov, "roiPosition" to fov.roiPosition),
+            mapOf("fov" to fov.fov, "roi_position" to fov.roiPosition),
         )
     }
 
     fun setMicState(
         enabled: Boolean,
         useGlassesMic: Boolean = true,
-        bypassVad: Boolean = true,
         sendTranscript: Boolean = false,
         sendLc3Data: Boolean = false,
     ) {
@@ -363,7 +379,6 @@ class MentraBluetoothSdk private constructor(
         applyMicState(
             sendPcmData = enabled,
             sendTranscript = enabled && sendTranscript,
-            bypassVad = bypassVad,
             sendLc3Data = enabled && sendLc3Data,
         )
     }
@@ -371,13 +386,11 @@ class MentraBluetoothSdk private constructor(
     private fun applyMicState(
         sendPcmData: Boolean,
         sendTranscript: Boolean,
-        bypassVad: Boolean,
         sendLc3Data: Boolean,
     ) {
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "should_send_pcm", sendPcmData)
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "should_send_lc3", sendLc3Data)
         DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "should_send_transcript", sendTranscript)
-        DeviceStore.apply(ObservableStore.BLUETOOTH_CATEGORY, "bypass_vad", bypassVad)
         deviceManager.setMicState()
     }
 
@@ -414,6 +427,9 @@ class MentraBluetoothSdk private constructor(
     }
 
     fun requestPhoto(request: PhotoRequest) {
+        Bridge.log(
+            "NATIVE: PHOTO PIPELINE [3b/6] MentraBluetoothSdk.requestPhoto requestId=${request.requestId} appId=${request.appId}"
+        )
         deviceManager.requestPhoto(
             request.requestId,
             request.appId,
@@ -421,7 +437,10 @@ class MentraBluetoothSdk private constructor(
             request.webhookUrl,
             request.authToken,
             request.compress.value,
+            request.flash,
             request.sound,
+            request.exposureTimeNs,
+            request.iso,
         )
     }
 
@@ -430,10 +449,18 @@ class MentraBluetoothSdk private constructor(
     }
 
     fun startStream(request: StreamRequest) {
-        deviceManager.startStream(request.toMap().toMutableMap())
+        val message = request.toMap().toMutableMap()
+        val streamId = (message["streamId"] as? String)?.takeIf { it.isNotBlank() }
+                ?: "sdk-${UUID.randomUUID()}"
+        message["streamId"] = streamId
+        stopStreamKeepAliveMonitor()
+        deviceManager.startStream(message)
+        if (request.keepAlive && !request.isExternallyManagedKeepAlive()) {
+            startStreamKeepAliveMonitor(streamId, request.keepAliveIntervalSeconds)
+        }
     }
 
-    fun keepStreamAlive(request: StreamKeepAliveRequest) {
+    internal fun sendCloudStreamKeepAlive(request: StreamKeepAliveRequest) {
         deviceManager.keepStreamAlive(request.toMap().toMutableMap())
     }
 
@@ -450,6 +477,7 @@ class MentraBluetoothSdk private constructor(
     }
 
     fun stopStream() {
+        stopStreamKeepAliveMonitor()
         deviceManager.stopStream()
     }
 
@@ -486,6 +514,7 @@ class MentraBluetoothSdk private constructor(
     }
 
     override fun close() {
+        stopStreamKeepAliveMonitor()
         Bridge.removeEventSink(bridgeEventSinkId)
         DeviceStore.store.removeListener(storeListenerId)
         listeners.clear()
@@ -605,6 +634,25 @@ class MentraBluetoothSdk private constructor(
                 }
             }
             "head_up" -> dispatchToListeners { it.onHeadUpChanged(data["up"] as? Boolean ?: false) }
+            "voice_activity_detection_status" ->
+                dispatchToListeners {
+                    it.onVoiceActivityDetectionStatus(
+                        VoiceActivityDetectionStatusEvent(
+                            voiceActivityDetectionEnabled =
+                                data["voiceActivityDetectionEnabled"] as? Boolean ?: true,
+                            values = data,
+                        )
+                    )
+                }
+            "speaking_status" ->
+                dispatchToListeners {
+                    it.onSpeakingStatus(
+                        SpeakingStatusEvent(
+                            speaking = data["speaking"] as? Boolean ?: false,
+                            values = data,
+                        )
+                    )
+                }
             "battery_status" ->
                 dispatchToListeners {
                     it.onBatteryStatus(
@@ -620,8 +668,18 @@ class MentraBluetoothSdk private constructor(
             "hotspot_error" -> dispatchToListeners { it.onHotspotError(HotspotErrorEvent(data)) }
             "gallery_status" -> dispatchToListeners { it.onGalleryStatus(GalleryStatusEvent(data)) }
             "photo_response" -> dispatchToListeners { it.onPhotoResponse(PhotoResponseEvent(data)) }
-            "stream_status" -> dispatchToListeners { it.onStreamStatus(StreamStatusEvent(data)) }
-            "keep_alive_ack" -> dispatchToListeners { it.onKeepAliveAck(KeepAliveAckEvent(data)) }
+            "photo_status" -> dispatchToListeners { it.onPhotoStatus(PhotoStatusEvent(data)) }
+            "stream_status" -> {
+                val event = StreamStatusEvent(data)
+                handleStreamStatusForKeepAlive(event.status)
+                dispatchToListeners { it.onStreamStatus(event) }
+            }
+            "keep_alive_ack" -> {
+                val event = KeepAliveAckEvent(data)
+                if (!handleStreamKeepAliveAck(event)) {
+                    dispatchToListeners { it.onKeepAliveAck(event) }
+                }
+            }
             "mic_pcm" -> {
                 val event = MicPcmEvent(data)
                 if (event.pcm.isNotEmpty()) {
@@ -676,4 +734,102 @@ class MentraBluetoothSdk private constructor(
             deliver()
         }
     }
+
+    private fun startStreamKeepAliveMonitor(streamId: String, requestedIntervalSeconds: Int) {
+        val intervalSeconds =
+                requestedIntervalSeconds.takeIf { it > 0 } ?: DEFAULT_STREAM_KEEP_ALIVE_INTERVAL_SECONDS
+        val tracker = ActiveStreamKeepAlive(
+                streamId = streamId,
+                intervalMs = intervalSeconds * 1_000L,
+        )
+        synchronized(streamKeepAliveLock) {
+            activeStreamKeepAlive = tracker
+        }
+        sendNextStreamKeepAlive(tracker)
+    }
+
+    private fun stopStreamKeepAliveMonitor() {
+        val tracker =
+                synchronized(streamKeepAliveLock) {
+                    val current = activeStreamKeepAlive
+                    activeStreamKeepAlive = null
+                    current
+                }
+        tracker?.nextTick?.let { mainHandler.removeCallbacks(it) }
+    }
+
+    private fun sendNextStreamKeepAlive(tracker: ActiveStreamKeepAlive) {
+        var timeoutEvent: StreamStatusEvent? = null
+        var request: StreamKeepAliveRequest? = null
+
+        synchronized(streamKeepAliveLock) {
+            if (activeStreamKeepAlive !== tracker) {
+                return
+            }
+
+            if (tracker.pendingAckId != null) {
+                tracker.missedAckCount += 1
+                if (tracker.missedAckCount >= MAX_MISSED_STREAM_KEEP_ALIVE_ACKS) {
+                    activeStreamKeepAlive = null
+                    tracker.nextTick?.let { mainHandler.removeCallbacks(it) }
+                    timeoutEvent =
+                            StreamStatusEvent(
+                                    StreamStatus.Error(
+                                            streamId = tracker.streamId,
+                                            errorDetails =
+                                                    "Stream keep-alive timed out after ${tracker.missedAckCount} missed ACKs",
+                                            timestamp = System.currentTimeMillis(),
+                                            resolvedConfig = null,
+                                    )
+                            )
+                    return@synchronized
+                }
+            }
+
+            val ackId = "ack-${System.currentTimeMillis()}"
+            tracker.pendingAckId = ackId
+            request = StreamKeepAliveRequest(streamId = tracker.streamId, ackId = ackId)
+            val nextTick = Runnable { sendNextStreamKeepAlive(tracker) }
+            tracker.nextTick = nextTick
+            mainHandler.postDelayed(nextTick, tracker.intervalMs)
+        }
+
+        timeoutEvent?.let { event ->
+            dispatchToListeners { it.onStreamStatus(event) }
+            return
+        }
+
+        request?.let { keepAlive ->
+            deviceManager.keepStreamAlive(keepAlive.toMap().toMutableMap())
+        }
+    }
+
+    private fun handleStreamKeepAliveAck(event: KeepAliveAckEvent): Boolean {
+        synchronized(streamKeepAliveLock) {
+            val tracker = activeStreamKeepAlive ?: return false
+            if (event.streamId != tracker.streamId || event.ackId != tracker.pendingAckId) {
+                return false
+            }
+            tracker.pendingAckId = null
+            tracker.missedAckCount = 0
+            return true
+        }
+    }
+
+    private fun handleStreamStatusForKeepAlive(status: StreamStatus) {
+        val streamId = status.streamId
+        if (
+                streamId != null &&
+                        synchronized(streamKeepAliveLock) { activeStreamKeepAlive?.streamId } != streamId
+        ) {
+            return
+        }
+        when (status.state) {
+            StreamState.STOPPED,
+            StreamState.STOPPING,
+            StreamState.ERROR,
+            StreamState.RECONNECT_FAILED -> stopStreamKeepAliveMonitor()
+            else -> Unit
+        }
+    }
 }

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

@@ -13,7 +13,7 @@ data class MicPcmEvent(
     val bitsPerSample: Int,
     val channels: Int,
     val encoding: String,
-    val vadGated: Boolean,
+    val voiceActivityDetectionEnabled: Boolean,
 ) {
     constructor(values: Map<String, Any>) : this(
         pcm = values["pcm"] as? ByteArray ?: ByteArray(0),
@@ -21,7 +21,7 @@ data class MicPcmEvent(
         bitsPerSample = numberValue(values, "bitsPerSample") ?: BITS_PER_SAMPLE,
         channels = numberValue(values, "channels") ?: CHANNELS,
         encoding = stringValue(values, "encoding") ?: ENCODING,
-        vadGated = boolValue(values, "vadGated") ?: false,
+        voiceActivityDetectionEnabled = boolValue(values, "voiceActivityDetectionEnabled") ?: true,
     )
 
     fun toMap(): Map<String, Any> =
@@ -32,7 +32,7 @@ data class MicPcmEvent(
             "bitsPerSample" to bitsPerSample,
             "channels" to channels,
             "encoding" to encoding,
-            "vadGated" to vadGated,
+            "voiceActivityDetectionEnabled" to voiceActivityDetectionEnabled,
         )
 
     companion object {
@@ -52,7 +52,7 @@ data class MicLc3Event(
     val frameSizeBytes: Int,
     val bitrate: Int,
     val packetizedFromGlasses: Boolean,
-    val vadGated: Boolean,
+    val voiceActivityDetectionEnabled: Boolean,
 ) {
     constructor(values: Map<String, Any>) : this(
         lc3 = values["lc3"] as? ByteArray ?: ByteArray(0),
@@ -63,7 +63,7 @@ data class MicLc3Event(
         frameSizeBytes = numberValue(values, "frameSizeBytes") ?: DEFAULT_FRAME_SIZE_BYTES,
         bitrate = numberValue(values, "bitrate") ?: DEFAULT_BITRATE,
         packetizedFromGlasses = boolValue(values, "packetizedFromGlasses") ?: false,
-        vadGated = boolValue(values, "vadGated") ?: false,
+        voiceActivityDetectionEnabled = boolValue(values, "voiceActivityDetectionEnabled") ?: true,
     )
 
     fun toMap(): Map<String, Any> =
@@ -77,7 +77,7 @@ data class MicLc3Event(
             "frameSizeBytes" to frameSizeBytes,
             "bitrate" to bitrate,
             "packetizedFromGlasses" to packetizedFromGlasses,
-            "vadGated" to vadGated,
+            "voiceActivityDetectionEnabled" to voiceActivityDetectionEnabled,
         )
 
     companion object {

package/android/src/main/java/com/mentra/bluetoothsdk/camera/CameraModels.kt

@@ -1,10 +1,5 @@
 package com.mentra.bluetoothsdk
 
-enum class GalleryMode {
-    AUTO,
-    MANUAL,
-}
-
 enum class PhotoSize(val value: String) {
     SMALL("small"),
     MEDIUM("medium"),
@@ -49,12 +44,24 @@ data class ButtonPhotoSettings(
 data class ButtonVideoRecordingSettings(
     val width: Int,
     val height: Int,
-    val frameRate: Int,
+    val fps: Int,
 )
 
-enum class CameraFov(val fov: Int, val roiPosition: Int) {
-    STANDARD(118, 0),
-    WIDE(118, 0),
+class CameraFov @JvmOverloads constructor(
+    fov: Int = DEFAULT_FOV,
+    roiPosition: Int = DEFAULT_ROI_POSITION,
+) {
+    val fov: Int = fov.coerceIn(MIN_FOV, MAX_FOV)
+    val roiPosition: Int = roiPosition.coerceIn(MIN_ROI_POSITION, MAX_ROI_POSITION)
+
+    companion object {
+        const val MIN_FOV = 82
+        const val MAX_FOV = 118
+        const val DEFAULT_FOV = 102
+        const val MIN_ROI_POSITION = 0
+        const val MAX_ROI_POSITION = 2
+        const val DEFAULT_ROI_POSITION = 0
+    }
 }
 
 data class PhotoRequest @JvmOverloads constructor(
@@ -64,8 +71,49 @@ data class PhotoRequest @JvmOverloads constructor(
     val webhookUrl: String,
     val authToken: String? = null,
     val compress: PhotoCompression = PhotoCompression.MEDIUM,
+    val flash: Boolean = true,
     val sound: Boolean = true,
-)
+    /** Sensor exposure time for this capture only (ns), or null for auto exposure */
+    val exposureTimeNs: Double? = null,
+    /** Sensor ISO for this capture only. Only used when exposureTimeNs enables manual exposure. */
+    val iso: Int? = null,
+) {
+    companion object {
+        /** Mirrors iOS `BluetoothSdkModule` defaults for keys omitted from the JS bridge. */
+        @JvmStatic
+        fun fromMap(values: Map<String, Any>): PhotoRequest {
+            val rawExp = values["exposureTimeNs"] ?: values["exposure_time_ns"]
+            val exposureTimeNs: Double? =
+                when (rawExp) {
+                    is Number -> rawExp.toDouble().takeIf { it.isFinite() && it > 0 }
+                    else -> null
+                }
+            val rawIso = values["iso"]
+            val iso: Int? =
+                when (rawIso) {
+                    is Number -> rawIso.toDouble().takeIf { it.isFinite() && it > 0 }?.let { value ->
+                        when {
+                            value > Int.MAX_VALUE.toDouble() -> Int.MAX_VALUE
+                            else -> value.toInt()
+                        }
+                    }
+                    else -> null
+                }
+            return PhotoRequest(
+                requestId = stringValue(values, "requestId", "request_id").orEmpty(),
+                appId = stringValue(values, "appId", "app_id").orEmpty(),
+                size = PhotoSize.fromValue(stringValue(values, "size") ?: "medium"),
+                webhookUrl = stringValue(values, "webhookUrl", "webhook_url").orEmpty(),
+                authToken = stringValue(values, "authToken", "auth_token")?.takeIf { it.isNotBlank() },
+                compress = PhotoCompression.fromValue(stringValue(values, "compress") ?: "none"),
+                flash = boolValue(values, "flash") ?: true,
+                sound = boolValue(values, "sound") ?: true,
+                exposureTimeNs = exposureTimeNs,
+                iso = iso,
+            )
+        }
+    }
+}
 
 enum class RgbLedAction(val value: String) {
     ON("on"),
@@ -185,3 +233,14 @@ data class PhotoResponseEvent(
     val requestId: String get() = response.requestId
     val values: Map<String, Any> get() = response.toEventMap()
 }
+
+data class PhotoStatusEvent(
+    val values: Map<String, Any>,
+) {
+    val requestId: String get() = stringValue(values, "requestId").orEmpty()
+    val status: String get() = stringValue(values, "status").orEmpty()
+    val timestamp: Long get() = longValue(values, "timestamp") ?: System.currentTimeMillis()
+    val resolvedConfig: Map<String, Any>? get() = stringMapValue(values["resolvedConfig"])
+    val errorCode: String? get() = stringValue(values, "errorCode")
+    val errorMessage: String? get() = stringValue(values, "errorMessage")
+}

package/android/src/main/java/com/mentra/bluetoothsdk/controllers/ControllerManager.kt

@@ -22,7 +22,9 @@ abstract class ControllerManager {
         authToken: String?,
         compress: String?,
         flash: Boolean,
-        sound: Boolean
+        sound: Boolean,
+        exposureTimeNs: Long?,
+        iso: Int?,
     )
     abstract fun startStream(message: Map<String, Any>)
     abstract fun stopStream()
@@ -132,8 +134,8 @@ abstract class ControllerManager {
     val micEnabled: Boolean
         get() = DeviceStore.get("glasses", "micEnabled") as? Boolean ?: false
 
-    val vadEnabled: Boolean
-        get() = DeviceStore.get("glasses", "vadEnabled") as? Boolean ?: false
+    val voiceActivityDetectionEnabled: Boolean
+        get() = DeviceStore.get("glasses", "voiceActivityDetectionEnabled") as? Boolean ?: true
 
     val batteryLevel: Int
         get() = DeviceStore.get("glasses", "batteryLevel") as? Int ?: -1

package/android/src/main/java/com/mentra/bluetoothsdk/controllers/R1.kt

@@ -863,7 +863,8 @@ class R1 : ControllerManager() {
     override fun sendJson(jsonOriginal: Map<String, Any>, wakeUp: Boolean, requireAck: Boolean) {}
     override fun requestPhoto(
         requestId: String, appId: String, size: String?, webhookUrl: String?,
-        authToken: String?, compress: String?, flash: Boolean, sound: Boolean
+        authToken: String?, compress: String?, flash: Boolean, sound: Boolean,
+        exposureTimeNs: Long?, iso: Int?,
     ) {}
     override fun startVideoRecording(requestId: String, save: Boolean, flash: Boolean, sound: Boolean) {}
     override fun stopVideoRecording(requestId: String) {}