@mentra/bluetooth-sdk 3.2.1-dev.277 → 3.2.1-dev.279

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

@@ -368,6 +368,10 @@ class BluetoothSdkModule : Module() {
             "receive_command_from_ble",
             "swipe_volume_status",
             "switch_status",
+            "mic_tuning_state",
+            "mic_rms",
+            "wear_state",
+            "wear_tuning",
             "rgb_led_control_response",
             "settings_ack",
             "version_info",
@@ -582,6 +586,33 @@ class BluetoothSdkModule : Module() {
         // Stub on Android — iOS uses this for the jetsam stress test.
         Function("getMemoryMB") { -> 0.0 }
 
+        // MARK: - Mic tuning (internal SDK surface only)
+
+        AsyncFunction("setMicRmsTelemetry") { enabled: Boolean ->
+            deviceManager?.sgc?.setMicRmsTelemetry(enabled)
+        }
+
+        // Fire-and-forget: the answer arrives as a mic_tuning_state event, which
+        // the screen is subscribed to anyway.
+        AsyncFunction("requestMicTuningState") { deviceManager?.sgc?.requestMicTuningState() }
+
+        // MARK: - Wear detection (internal SDK surface only)
+
+        // All fire-and-forget; answers arrive as wear_state / wear_tuning events.
+        AsyncFunction("queryWearState") { deviceManager?.queryWearState() }
+
+        AsyncFunction("setWearReporting") { enabled: Boolean ->
+            deviceManager?.setWearReporting(enabled)
+        }
+
+        AsyncFunction("setWearTuning") { intervalMs: Int, count: Int, majority: Int ->
+            deviceManager?.setWearTuning(intervalMs, count, majority)
+        }
+
+        AsyncFunction("requestWearTuning") { deviceManager?.requestWearTuning() }
+
+        AsyncFunction("resetWearTuning") { deviceManager?.resetWearTuning() }
+
         // MARK: - Incident Reporting
 
         SdkAsyncFunction("sendIncidentId") { incidentId: String, apiBaseUrl: String? ->

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

@@ -391,6 +391,40 @@ public class Bridge private constructor() {
             sendTypedMessage("switch_status", body)
         }
 
+        /**
+         * Mic tuning values the glasses report as actually in force (post-clamp),
+         * from sr_mictun / sr_micst.
+         */
+        @JvmStatic
+        fun sendMicTuningState(state: Map<String, Any>) {
+            sendTypedMessage("mic_tuning_state", HashMap(state))
+        }
+
+        /** Wear state from sr_wrst, or from a wear transition on the glasses. */
+        @JvmStatic
+        fun sendWearState(worn: Boolean) {
+            val body = HashMap<String, Any>()
+            body["worn"] = worn
+            sendTypedMessage("wear_state", body)
+        }
+
+        /** Wear vote config the glasses report as in force, from sr_weartun. */
+        @JvmStatic
+        fun sendWearTuningState(state: Map<String, Any>) {
+            sendTypedMessage("wear_tuning", HashMap(state))
+        }
+
+        /** Disposable mic RMS sample from sr_micrms. */
+        @JvmStatic
+        fun sendMicRms(rms: Int, gateOpen: Boolean, speakerElevated: Boolean, generation: Int) {
+            val body = HashMap<String, Any>()
+            body["rms"] = rms
+            body["gateOpen"] = gateOpen
+            body["speakerElevated"] = speakerElevated
+            body["generation"] = generation
+            sendTypedMessage("mic_rms", body)
+        }
+
         @JvmStatic
         fun sendPhotoError(requestId: String, errorCode: String, errorMessage: String) {
             val timestamp = System.currentTimeMillis()

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

@@ -1883,6 +1883,31 @@ class DeviceManager {
         sgc?.dbg2()
     }
 
+    fun queryWearState() {
+        Bridge.log("MAN: queryWearState()")
+        sgc?.queryWearState()
+    }
+
+    fun setWearReporting(enabled: Boolean) {
+        Bridge.log("MAN: setWearReporting($enabled)")
+        sgc?.setWearReporting(enabled)
+    }
+
+    fun setWearTuning(intervalMs: Int, count: Int, majority: Int) {
+        Bridge.log("MAN: setWearTuning($intervalMs, $count, $majority)")
+        sgc?.setWearTuning(intervalMs, count, majority)
+    }
+
+    fun requestWearTuning() {
+        Bridge.log("MAN: requestWearTuning()")
+        sgc?.requestWearTuning()
+    }
+
+    fun resetWearTuning() {
+        Bridge.log("MAN: resetWearTuning()")
+        sgc?.resetWearTuning()
+    }
+
     fun startStream(message: MutableMap<String, Any>) {
         Bridge.log("MAN: startStream")
         sgc?.startStream(message)

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

@@ -31,6 +31,16 @@ object DeviceStore {
                 JSONObject(mapOf("v" to newValue)).toString()
     }
 
+    /**
+     * Empty/`reset` mic tuning must still be written to the glasses. Native
+     * `update` drops null, and equal empty maps would otherwise skip BLE.
+     */
+    private fun isMicTuningReset(value: Any): Boolean {
+        val map = value as? Map<*, *> ?: return true
+        if (map.isEmpty()) return true
+        return map.entries.none { (key, field) -> key != "reset" && field is Number }
+    }
+
     private fun scheduleDashboardHeightToGlasses() {
         pendingDashboardHeightRunnable?.let { dashboardBleHandler.removeCallbacks(it) }
         val r = Runnable {
@@ -164,7 +174,10 @@ object DeviceStore {
     fun apply(category: String, key: String, value: Any) {
         val oldValue = store.get(category, key)
         store.set(category, key, value)
-        if (observableStoreWouldHaveSkipped(oldValue, value)) {
+        val skipped = observableStoreWouldHaveSkipped(oldValue, value)
+        val forceMicReset =
+                category == ObservableStore.BLUETOOTH_CATEGORY && key == "mic_tuning" && isMicTuningReset(value)
+        if (skipped && !forceMicReset) {
             return
         }
 
@@ -278,6 +291,12 @@ object DeviceStore {
             "bluetooth" to "loudness_gate_enabled" -> {
                 DeviceManager.getInstance().sgc?.sendLoudnessGateSetting()
             }
+            // 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.
+            "bluetooth" to "mic_tuning" -> {
+                DeviceManager.getInstance().sgc?.sendMicTuningSetting()
+            }
             "bluetooth" to "nex_lc3_audio_playback" -> {
                 (value as? Boolean)?.let { enabled ->
                     Bridge.log("DeviceStore: nex_lc3_audio_playback changed to $enabled")

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.277"
-    const val RELEASE_SET_ID: String = "mentra-3.2.1-dev.277"
-    const val SOURCE_COMMIT: String = "2668275c49728812fea5356f6df3e78e73f1ed87"
-    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.277.json"
-    const val OTA_MANIFEST_SHA256: String = "527d30a6400d5accdbf83e2c4316ec6e30e2b7ef1d70b6fd54e7abcec1bcc183"
+    const val RELEASE_IDENTITY: String = "3.2.1-dev.279"
+    const val RELEASE_SET_ID: String = "mentra-3.2.1-dev.279"
+    const val SOURCE_COMMIT: String = "b89b07413c06947f1a2f4a321ce23927eaebd4e4"
+    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.279.json"
+    const val OTA_MANIFEST_SHA256: String = "725cccaec20e39be8f75dbe1e511092aa4812ab46cade44a583843282f0c0eb3"
 }

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

@@ -141,6 +141,9 @@ class MentraLive : SGCManager() {
         private const val LC3_FRAME_SIZE = 40
         private const val VOICE_ACTIVITY_DETECTION_SWITCH_TYPE = 8
         private const val LOUDNESS_GATE_SWITCH_TYPE = 10
+        // Mic tuning field names, matching the BES cs_mictun body.
+        private val MIC_TUNING_FIELDS =
+                listOf("gain", "open", "close", "attack", "hang", "sp_open", "sp_close", "sp_hold")
         private const val BES2700_MTU_LIMIT = 509
         private const val A2DP_CONNECT_MAX_ATTEMPTS = 5
         private const val A2DP_CONNECT_RETRY_MS = 800L
@@ -532,6 +535,22 @@ class MentraLive : SGCManager() {
     private var peerK900Le = false
     private var peerWireCapsBinary = false
     private var peerFilePayloadV2 = false
+    // Firmware understands cs_mictun / cs_micst / cs_micrms. Nothing mic-tuning
+    // related goes on the wire until this is seen.
+    private var peerMicTuning = false
+    private var peerWearTuning = false
+    // Connect-time dedupe. Three paths push mic tuning when a link comes up
+    // (sendUserSettings, the wire_caps advertisement, the engine's settings
+    // replay) and the wire_caps parse re-runs on every glasses_ready, so a
+    // single connect used to cost two identical cs_mictun and several
+    // cs_wearst. The glasses only lose tuning state on BLE disconnect, so an
+    // identical body within one link is a no-op and is dropped here. Both
+    // reset when the link drops (updateConnectionState -> DISCONNECTED).
+    private var lastSentMicTuningBody: String? = null
+    private var wearTuningQueriedThisLink = false
+    // Tuning generation echoed by the last sr_mictun / sr_micst. An sr_micrms
+    // measured before that revision describes a config we already replaced.
+    private var micTuningGeneration = 0
     // Last observed glasses process session id (`sid` in glasses_ready / version_info_1).
     // The BES keeps the BLE link alive across asg_client restarts, so transport state
     // cannot signal a restart - a CHANGED (or newly appearing) sid is the restart signal.
@@ -1219,6 +1238,10 @@ class MentraLive : SGCManager() {
             DeviceStore.apply("glasses", "signalStrengthUpdatedAt", 0L)
             resetWireNegotiationState()
             resetPendingAckState()
+            // The glasses reset mic and wear tuning on BLE disconnect, so the
+            // next link must be allowed to send them again.
+            lastSentMicTuningBody = null
+            wearTuningQueriedThisLink = false
             sendQueue.clear() // see the disconnect reset above: stale writes die with the session
 
             // Drop OTA caches when fully disconnected — avoids leaking session/step state
@@ -5531,6 +5554,55 @@ class MentraLive : SGCManager() {
                     Log.e(TAG, "Error parsing sr_swit response", e)
                 }
             }
+            "sr_mictun", "sr_micst" -> {
+                try {
+                    val bodyObj = optK900Body(json)
+                    if (bodyObj != null) {
+                        handleMicTuningState(bodyObj)
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error parsing mic tuning state", e)
+                }
+            }
+            "sr_weartun" -> {
+                try {
+                    val bodyObj = optK900Body(json)
+                    if (bodyObj != null) {
+                        handleWearTuningState(json, bodyObj)
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error parsing wear tuning state", e)
+                }
+            }
+            "sr_wrst" -> {
+                try {
+                    val bodyObj = optK900Body(json)
+                    if (bodyObj != null) {
+                        Bridge.sendWearState(bodyObj.optInt("on", 0) != 0)
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error parsing sr_wrst response", e)
+                }
+            }
+            "sr_micrms" -> {
+                try {
+                    val bodyObj = optK900Body(json)
+                    if (bodyObj != null) {
+                        val generation = bodyObj.optInt("gen", 0)
+                        // Measured under a config we have already replaced.
+                        if (generation >= micTuningGeneration) {
+                            Bridge.sendMicRms(
+                                    bodyObj.optInt("rms", 0),
+                                    bodyObj.optInt("gate", 0) != 0,
+                                    bodyObj.optInt("sp", 0) != 0,
+                                    generation
+                            )
+                        }
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error parsing sr_micrms response", e)
+                }
+            }
             "sr_shut" -> {
                 Bridge.log("LIVE: K900 shutdown command received - glasses shutting down")
                 lastShutdownTimeMs = System.currentTimeMillis()
@@ -5828,6 +5900,39 @@ class MentraLive : SGCManager() {
         return !(value is Boolean) || value
     }
 
+    /**
+     * Post-clamp tuning the glasses report as in force. Forwarded verbatim so
+     * the screen can show the applied value next to the requested one.
+     */
+    private fun handleMicTuningState(body: JSONObject) {
+        val state = HashMap<String, Any>()
+        for (name in MIC_TUNING_FIELDS) {
+            if (body.has(name)) state[name] = body.optInt(name, 0)
+        }
+        val generation = body.optInt("gen", 0)
+        state["generation"] = generation
+        state["overridden"] = body.optInt("ovr", 0) != 0
+        micTuningGeneration = generation
+        Bridge.sendMicTuningState(state)
+    }
+
+    /**
+     * What the wear poll loop is actually running. A rejected patch comes back
+     * with the unchanged values and a non-zero result code, so the screen can
+     * show that the request did not take.
+     */
+    private fun handleWearTuningState(json: JSONObject, body: JSONObject) {
+        val state = HashMap<String, Any>()
+        state["enabled"] = body.optInt("enabled", 0) != 0
+        state["interval"] = body.optInt("interval", 0)
+        state["count"] = body.optInt("count", 0)
+        state["majority"] = body.optInt("majority", 0)
+        state["generation"] = body.optInt("gen", 0)
+        // K900 replies carry the result code in "S"; 0 is RC_SUCCESS.
+        state["accepted"] = json.optInt("S", 0) == 0
+        Bridge.sendWearTuningState(state)
+    }
+
     private fun handleSwitchStatus(switchType: Int, switchValue: Int, timestamp: Long) {
         Bridge.sendSwitchStatus(switchType, switchValue, timestamp)
         if (switchType == VOICE_ACTIVITY_DETECTION_SWITCH_TYPE &&
@@ -8879,6 +8984,9 @@ class MentraLive : SGCManager() {
         peerK900Le = false
         peerWireCapsBinary = false
         peerFilePayloadV2 = false
+        peerWearTuning = false
+        peerMicTuning = false
+        micTuningGeneration = 0
         BleJsonCompact.resetSession()
         wireHandshakeSentGeneration = -1
     }
@@ -8954,6 +9062,32 @@ class MentraLive : SGCManager() {
         if (caps.has("file_payload_v2")) {
             peerFilePayloadV2 = caps.optBoolean("file_payload_v2", false)
         }
+        if (caps.has("wear_tuning") && !peerWearTuning) {
+            // Firmware advertises this as a JSON bool (`true`), not `1`.
+            // optInt("wear_tuning") returns 0 for a boolean and used to
+            // no-op every Super Mode wear button.
+            peerWearTuning = jsonFlagOn(caps, "wear_tuning")
+            if (peerWearTuning) {
+                Bridge.log("LIVE: wire_caps wear_tuning supported")
+                // Nothing to push: wear reporting starts off on the glasses
+                // and stays off until the tuning screen asks for it. One read
+                // per link: the flag is cleared on every wire epoch, but the
+                // glasses only forget tuning on BLE disconnect.
+                if (!wearTuningQueriedThisLink) {
+                    wearTuningQueriedThisLink = true
+                    requestWearTuning()
+                }
+            }
+        }
+        if (caps.has("mic_tuning") && !peerMicTuning) {
+            peerMicTuning = jsonFlagOn(caps, "mic_tuning")
+            if (peerMicTuning) {
+                // Caps can arrive after the on-connect batch already ran, in
+                // which case the tuning send was skipped. Do it now.
+                Bridge.log("LIVE: wire_caps mic_tuning supported")
+                sendMicTuningSetting()
+            }
+        }
     }
 
     private fun advertiseFilePayloadCapabilityToBes() {
@@ -10682,6 +10816,209 @@ class MentraLive : SGCManager() {
 
         // Send glasses-side loudness / Barrier gate setting.
         sendLoudnessGateSetting()
+
+        // Send mic tuning. With nothing authorized this sends a reset, which is
+        // what returns a freshly connected pair of glasses to stock behaviour.
+        sendMicTuningSetting()
+    }
+
+    /**
+     * Push the effective mic tuning to the glasses.
+     *
+     * The store holds only what the engine has authorized for this process; a
+     * missing value means "no tuning", which is sent as an explicit reset
+     * rather than silently skipped. That is what keeps a persisted super-mode
+     * value from surviving into a session where super mode is off.
+     */
+    override fun sendMicTuningSetting() {
+        if (!isConnected) {
+            Bridge.log("LIVE: Cannot send mic tuning - not connected")
+            return
+        }
+        if (!peerMicTuning) {
+            Bridge.log("LIVE: mic_tuning cap not advertised; sending cs_mictun anyway")
+        }
+
+        try {
+            val tuning = DeviceStore.get("bluetooth", "mic_tuning")
+            val body = JSONObject()
+            @Suppress("UNCHECKED_CAST")
+            val fields = tuning as? Map<String, Any>
+            var sent = 0
+            if (fields != null) {
+                for (name in MIC_TUNING_FIELDS) {
+                    val raw = fields[name]
+                    val number = raw as? Number ?: continue
+                    body.put(name, number.toInt())
+                    sent++
+                }
+            }
+            if (sent == 0) {
+                body.put("reset", 1)
+            }
+
+            val serialized = body.toString()
+            if (serialized == lastSentMicTuningBody) {
+                Bridge.log("LIVE: 🎚️ Mic tuning unchanged this link, not resending: " + serialized)
+                return
+            }
+
+            Bridge.log("LIVE: 🎚️ Sending mic tuning to glasses: " + serialized)
+
+            val cmdObject = JSONObject()
+            cmdObject.put("C", "cs_mictun")
+            cmdObject.put("V", 1)
+            cmdObject.put("B", body.toString())
+
+            val packedData =
+                    K900ProtocolUtils.packDataToK900(
+                            cmdObject.toString().toByteArray(StandardCharsets.UTF_8),
+                            K900ProtocolUtils.CMD_TYPE_STRING,
+                            k900LengthEndian()
+                    )
+            if (packedData == null) {
+                Bridge.log("LIVE: Failed to pack mic tuning command")
+                return
+            }
+            queueData(packedData)
+            lastSentMicTuningBody = serialized
+        } catch (e: JSONException) {
+            Log.e(TAG, "Error creating mic tuning command", e)
+        }
+    }
+
+    /** Ask the glasses what tuning they are actually running (sr_micst). */
+    override fun requestMicTuningState() {
+        if (!isConnected) {
+            Bridge.log("LIVE: Cannot send cs_micst - not connected")
+            return
+        }
+        if (!peerMicTuning) {
+            Bridge.log("LIVE: mic_tuning cap not advertised; sending cs_micst anyway")
+        }
+        sendMicTuningCommand("cs_micst", JSONObject())
+    }
+
+    /** Read the current wear state (sr_wrst). Always available. */
+    override fun queryWearState() {
+        sendWearCommandIfReady("cs_wrst", JSONObject())
+    }
+
+    /**
+     * Turn wear reporting on or off for this session.
+     *
+     * Deliberately not the NV-backed cs_swit type 1: the glasses must forget
+     * this on disconnect, and any later switch write would re-persist a wear
+     * bit that had been enabled once.
+     */
+    override fun setWearReporting(enabled: Boolean) {
+        val body = JSONObject()
+        body.put("enabled", if (enabled) 1 else 0)
+        sendWearCommandIfReady("cs_weartun", body)
+    }
+
+    /** Move the debounce vote. Negative means "leave this one alone". */
+    override fun setWearTuning(intervalMs: Int, count: Int, majority: Int) {
+        val body = JSONObject()
+        if (intervalMs >= 0) body.put("interval", intervalMs)
+        if (count >= 0) body.put("count", count)
+        if (majority >= 0) body.put("majority", majority)
+        if (body.length() == 0) return
+        sendWearCommandIfReady("cs_weartun", body)
+    }
+
+    /** Ask what the poll loop is actually running (sr_weartun). */
+    override fun requestWearTuning() {
+        sendWearCommandIfReady("cs_wearst", JSONObject())
+    }
+
+    /**
+     * Restore firmware defaults and disable reporting. Distinct from sending
+     * the default vote values, which would leave reporting on.
+     */
+    override fun resetWearTuning() {
+        val body = JSONObject()
+        body.put("reset", 1)
+        sendWearCommandIfReady("cs_weartun", body)
+    }
+
+    /**
+     * JSON wire_caps flags arrive as bools (`true`) or ints (`1`).
+     * [JSONObject.optInt] returns 0 for a boolean, which used to hide
+     * advertised capabilities.
+     */
+    private fun jsonFlagOn(obj: JSONObject, key: String): Boolean {
+        if (!obj.has(key) || obj.isNull(key)) return false
+        return when (val value = obj.opt(key)) {
+            is Boolean -> value
+            is Number -> value.toInt() != 0
+            is String -> value == "1" || value.equals("true", ignoreCase = true)
+            else -> false
+        }
+    }
+
+    private fun sendWearCommandIfReady(command: String, body: JSONObject) {
+        if (!isConnected) {
+            Bridge.log("LIVE: Cannot send $command - not connected")
+            return
+        }
+        if (!peerWearTuning && command != "cs_wrst") {
+            Bridge.log("LIVE: wear_tuning cap not advertised; sending $command anyway")
+        }
+        sendWearCommand(command, body)
+    }
+
+    private fun sendWearCommand(command: String, body: JSONObject) {
+        try {
+            val cmdObject = JSONObject()
+            cmdObject.put("C", command)
+            cmdObject.put("V", 1)
+            cmdObject.put("B", body.toString())
+            val packedData =
+                    K900ProtocolUtils.packDataToK900(
+                            cmdObject.toString().toByteArray(StandardCharsets.UTF_8),
+                            K900ProtocolUtils.CMD_TYPE_STRING,
+                            k900LengthEndian()
+                    )
+            if (packedData == null) {
+                Bridge.log("LIVE: Failed to pack " + command)
+                return
+            }
+            Bridge.log("LIVE: 👓 " + command + " " + body.toString())
+            queueData(packedData)
+        } catch (e: JSONException) {
+            Log.e(TAG, "Error creating " + command, e)
+        }
+    }
+
+    /** Enable or disable the sr_micrms readout. */
+    override fun setMicRmsTelemetry(enabled: Boolean) {
+        if (!isConnected || !peerMicTuning) return
+        val body = JSONObject()
+        body.put("on", if (enabled) 1 else 0)
+        sendMicTuningCommand("cs_micrms", body)
+    }
+
+    private fun sendMicTuningCommand(command: String, body: JSONObject) {
+        try {
+            val cmdObject = JSONObject()
+            cmdObject.put("C", command)
+            cmdObject.put("V", 1)
+            cmdObject.put("B", body.toString())
+            val packedData =
+                    K900ProtocolUtils.packDataToK900(
+                            cmdObject.toString().toByteArray(StandardCharsets.UTF_8),
+                            K900ProtocolUtils.CMD_TYPE_STRING,
+                            k900LengthEndian()
+                    )
+            if (packedData == null) {
+                Bridge.log("LIVE: Failed to pack " + command)
+                return
+            }
+            queueData(packedData)
+        } catch (e: JSONException) {
+            Log.e(TAG, "Error creating " + command, e)
+        }
     }
 
     override fun sendVoiceActivityDetectionSetting() {

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

@@ -350,6 +350,19 @@ abstract class SGCManager {
     // Mentra Live center-mic loudness / Barrier gate
     open fun sendLoudnessGateSetting() {}
 
+    // Mentra Live mic tuning (super-mode only). No value authorized means the
+    // implementation sends an explicit reset rather than skipping the send.
+    open fun sendMicTuningSetting() {}
+    open fun requestMicTuningState() {}
+    open fun setMicRmsTelemetry(enabled: Boolean) {}
+
+    // Wear detection (Mentra Live only; super-mode tooling).
+    open fun queryWearState() {}
+    open fun setWearReporting(enabled: Boolean) {}
+    open fun setWearTuning(intervalMs: Int, count: Int, majority: Int) {}
+    open fun requestWearTuning() {}
+    open fun resetWearTuning() {}
+
     // Start/stop LC3 audio playback from glasses based on the nex_lc3_audio_playback flag.
     open fun applyNexAudioPlaybackSetting() {}