@mentra/bluetooth-sdk 3.2.0-dev.266 → 3.2.1-beta.315

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 &&
@@ -6042,6 +6147,14 @@ class MentraLive : SGCManager() {
         }
     }
 
+    fun sendGalleryServerEnabled(requestId: String, enabled: Boolean) {
+        val json = JSONObject()
+            .put("type", "set_gallery_server_enabled")
+            .put("request_id", requestId)
+            .put("enabled", enabled)
+        sendJson(json, true)
+    }
+
     override fun sendGalleryMode() {
         val active = DeviceStore.get("bluetooth", "gallery_mode") as Boolean
         sendGalleryMode(null, active)
@@ -8879,6 +8992,9 @@ class MentraLive : SGCManager() {
         peerK900Le = false
         peerWireCapsBinary = false
         peerFilePayloadV2 = false
+        peerWearTuning = false
+        peerMicTuning = false
+        micTuningGeneration = 0
         BleJsonCompact.resetSession()
         wireHandshakeSentGeneration = -1
     }
@@ -8954,6 +9070,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 +10824,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() {}
 

package/build/BluetoothSdk.types.d.ts

@@ -386,6 +386,78 @@ export type SwitchStatusEvent = {
     switchValue?: number;
     timestamp: number;
 };
+/**
+ * Mentra Live center-mic gate + ADC gain overrides. Internal SDK surface: this
+ * is a super-mode tuning aid, not a public capability.
+ *
+ * Every field is optional; an omitted field keeps the firmware default. The
+ * glasses hold these in RAM only and drop them on disconnect, so the phone
+ * re-sends on every connect.
+ */
+export type MicTuning = {
+    /** codec_adc_vol index, 0-15. 15 is +32 dB, the top of the table. */
+    gain?: number;
+    /** Gate open / close thresholds, linear RMS on int16 samples. */
+    open?: number;
+    close?: number;
+    /** Frames of 10 ms. */
+    attack?: number;
+    hang?: number;
+    /** Thresholds used while the speaker is active or within its hold-off. */
+    sp_open?: number;
+    sp_close?: number;
+    sp_hold?: number;
+};
+/**
+ * What the glasses report as actually in force, after their own clamping. Use
+ * this rather than the requested value when showing applied settings.
+ */
+export type MicTuningStateEvent = MicTuning & {
+    type: "mic_tuning_state";
+    /** Tuning revision; increments on every accepted set or reset. */
+    generation: number;
+    /** True when any override is in force. */
+    overridden: boolean;
+};
+/** Live center-mic level. Disposable: samples are dropped under any pressure. */
+export type MicRmsEvent = {
+    type: "mic_rms";
+    rms: number;
+    gateOpen: boolean;
+    speakerElevated: boolean;
+    /** Tuning revision the sample was measured under. */
+    generation: number;
+};
+/**
+ * Mentra Live wear-detection vote. Internal SDK surface: Super Mode only.
+ * Values live in RAM on the glasses and reset on disconnect.
+ */
+export type WearTuning = {
+    /** Poll period in milliseconds. Firmware clamp: 50–2000. */
+    interval?: number;
+    /** Sliding-window length. Firmware clamp: 3–15. */
+    count?: number;
+    /** Votes needed to flip, either direction. Must be > count/2 and ≤ count. */
+    majority?: number;
+};
+/** Current wear vote from sr_wrst, or an unsolicited wear transition. */
+export type WearStateEvent = {
+    type: "wear_state";
+    worn: boolean;
+};
+/**
+ * What the wear poll loop is actually running. A rejected patch echoes the
+ * unchanged values with `accepted: false`.
+ */
+export type WearTuningEvent = WearTuning & {
+    type: "wear_tuning";
+    enabled: boolean;
+    interval: number;
+    count: number;
+    majority: number;
+    generation: number;
+    accepted: boolean;
+};
 export type RgbLedControlResponseEvent = {
     type: "rgb_led_control_response";
     state: "success";
@@ -400,7 +472,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_fov_override" | "camera_tuning";
+export type SettingsAckSetting = "gallery_server" | "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;
@@ -418,6 +490,10 @@ export type SettingsAckEvent = {
     fps?: number;
     enabled?: boolean;
     minutes?: number;
+    /** Current site-network listener state; present for gallery_server acknowledgements. */
+    listening?: boolean;
+    /** Current HTTP base URL; present for gallery_server only while listening. */
+    url?: string;
     /** ANR enabled flag; present when setting === "camera_tuning" */
     anr?: boolean;
     /** Stock-gain flag; present when setting === "camera_tuning" */
@@ -900,6 +976,10 @@ export type BluetoothSdkModuleEvents = {
     heartbeat_received: (event: HeartbeatReceivedEvent) => void;
     swipe_volume_status: (event: SwipeVolumeStatusEvent) => void;
     switch_status: (event: SwitchStatusEvent) => void;
+    mic_tuning_state: (event: MicTuningStateEvent) => void;
+    mic_rms: (event: MicRmsEvent) => void;
+    wear_state: (event: WearStateEvent) => void;
+    wear_tuning: (event: WearTuningEvent) => void;
     rgb_led_control_response: (event: RgbLedControlResponseEvent) => void;
     settings_ack: (event: SettingsAckEvent) => void;
     pair_failure: (event: PairFailureEvent) => void;
@@ -1036,6 +1116,10 @@ export type BluetoothSdkEventMap = {
     compatible_glasses_search_stop: CompatibleGlassesSearchStopEvent;
     swipe_volume_status: SwipeVolumeStatusEvent;
     switch_status: SwitchStatusEvent;
+    mic_tuning_state: MicTuningStateEvent;
+    mic_rms: MicRmsEvent;
+    wear_state: WearStateEvent;
+    wear_tuning: WearTuningEvent;
     rgb_led_control_response: RgbLedControlResponseEvent;
     settings_ack: SettingsAckEvent;
     pair_failure: PairFailureEvent;
@@ -1111,6 +1195,12 @@ export interface BluetoothSdkPublicModule {
     setSystemTime(timestampMs: number): Promise<void>;
     /** Enable or disable Wi-Fi ADB on Mentra Live (no-op on other devices). */
     setWifiAdbState(enabled: boolean): Promise<void>;
+    /**
+     * Persistently enable/disable unauthenticated HTTP gallery access on the glasses' Wi-Fi.
+     * Default off; survives reconnects/restarts until disabled. Only use on trusted networks.
+     * Returns saved enabled state plus current listening/url. No Wi-Fi means listening=false.
+     */
+    setGalleryServerEnabled(enabled: boolean): Promise<SettingsAckSuccessEvent>;
     setGalleryModeEnabled(enabled: boolean): Promise<SettingsAckSuccessEvent>;
     setVoiceActivityDetectionEnabled(enabled: boolean): Promise<void>;
     setLoudnessGateEnabled(enabled: boolean): Promise<void>;
@@ -1415,6 +1505,8 @@ export type BluetoothSettingsUpdate = Partial<{
     gallery_mode: boolean;
     voice_activity_detection_enabled: boolean;
     loudness_gate_enabled: boolean;
+    /** Effective mic tuning only. `{}` means "reset to firmware defaults". */
+    mic_tuning: MicTuning;
     button_photo_size: ButtonPhotoSize;
     button_video_settings: {
         width: number;