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

package/ios/Source/sgcs/MentraLive.swift

@@ -1060,6 +1060,10 @@ extension MentraLive: CBCentralManagerDelegate {
             self.readinessCompletedThisBleSession = false
             self.updateConnectionState(ConnTypes.DISCONNECTED)
             self.rgbLedAuthorityClaimed = false
+            // The glasses reset mic and wear tuning on BLE disconnect, so the
+            // next link must be allowed to send them again.
+            self.lastSentMicTuningBody = nil
+            self.wearTuningQueriedThisLink = false
 
             self.stopAllTimers()
             self.closeL2capFileChannel()
@@ -1698,6 +1702,21 @@ class MentraLive: NSObject, SGCManager {
     private var ancsRelayEnableRequested = 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
+    /// Firmware understands cs_weartun / cs_wearst. Wear reporting stays off
+    /// until Super Mode asks for it; this flag only gates those commands.
+    private var peerWearTuning = 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
+    /// Connect-time dedupe, mirroring Android. Several paths push mic tuning
+    /// when a link comes up and the wire_caps parse re-runs per glasses_ready;
+    /// the glasses only forget tuning on BLE disconnect, so an identical body
+    /// within one link is dropped. Both reset in didDisconnectPeripheral.
+    private var lastSentMicTuningBody: String?
+    private var wearTuningQueriedThisLink = false
     /// 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.
@@ -3427,6 +3446,35 @@ class MentraLive: NSObject, SGCManager {
                 )
             }
 
+        case "sr_mictun", "sr_micst":
+            if let body = k900ParseBody(json["B"]) {
+                handleMicTuningState(body)
+            }
+
+        case "sr_weartun":
+            if let body = k900ParseBody(json["B"]) {
+                handleWearTuningState(json, body)
+            }
+
+        case "sr_wrst":
+            if let body = k900ParseBody(json["B"]) {
+                Bridge.sendWearState(worn: (k900JsonInt(body, "on") ?? 0) != 0)
+            }
+
+        case "sr_micrms":
+            if let body = k900ParseBody(json["B"]) {
+                let generation = k900JsonInt(body, "gen") ?? 0
+                // Measured under a config we have already replaced.
+                if generation >= micTuningGeneration {
+                    Bridge.sendMicRms(
+                        rms: k900JsonInt(body, "rms") ?? 0,
+                        gateOpen: (k900JsonInt(body, "gate") ?? 0) != 0,
+                        speakerElevated: (k900JsonInt(body, "sp") ?? 0) != 0,
+                        generation: generation
+                    )
+                }
+            }
+
         case "sr_shut":
             Bridge.log("K900 shutdown command received - glasses shutting down")
             // Mark as killed to prevent reconnection attempts
@@ -6049,6 +6097,9 @@ extension MentraLive {
         peerK900Le = false
         peerWireCapsBinary = false
         peerFilePayloadV2 = false
+        peerWearTuning = false
+        peerMicTuning = false
+        micTuningGeneration = 0
         BleJsonCompact.resetSession()
         wireHandshakeSentGeneration = -1
     }
@@ -6118,6 +6169,33 @@ extension MentraLive {
         if caps.keys.contains("file_payload_v2") {
             peerFilePayloadV2 = (caps["file_payload_v2"] as? Bool) == true
         }
+        if caps.keys.contains("wear_tuning"), !peerWearTuning {
+            let supported = (caps["wear_tuning"] as? Bool) == true
+                || ((caps["wear_tuning"] as? NSNumber)?.intValue ?? 0) != 0
+            if supported {
+                peerWearTuning = true
+                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.keys.contains("mic_tuning"), !peerMicTuning {
+            let supported = (caps["mic_tuning"] as? Bool) == true
+                || ((caps["mic_tuning"] as? NSNumber)?.intValue ?? 0) != 0
+            if supported {
+                peerMicTuning = true
+                // Caps can land after the on-connect batch already ran, which
+                // would have skipped the tuning send.
+                Bridge.log("LIVE: wire_caps mic_tuning supported")
+                sendMicTuningSetting()
+            }
+        }
     }
 
     private func advertiseFilePayloadCapabilityToBes() {
@@ -6786,6 +6864,165 @@ extension MentraLive {
 
         // 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()
+    }
+
+    /// Mic tuning field names, matching the BES cs_mictun body.
+    private static let micTuningFields = [
+        "gain", "open", "close", "attack", "hang", "sp_open", "sp_close", "sp_hold",
+    ]
+
+    /// 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.
+    func sendMicTuningSetting() {
+        guard connectedPeripheral != nil, txCharacteristic != nil else {
+            Bridge.log("LIVE: Cannot send mic tuning - BLE write path not ready")
+            return
+        }
+        if !peerMicTuning {
+            Bridge.log("LIVE: mic_tuning cap not advertised; sending cs_mictun anyway")
+        }
+
+        var body: [String: Any] = [:]
+        if let fields = DeviceStore.shared.get("bluetooth", "mic_tuning") as? [String: Any] {
+            for name in Self.micTuningFields {
+                if let number = fields[name] as? NSNumber {
+                    body[name] = number.intValue
+                }
+            }
+        }
+        if body.isEmpty {
+            body["reset"] = 1
+        }
+
+        // Key order is fixed so equal bodies serialize identically.
+        let serialized = body.keys.sorted().map { "\($0)=\(body[$0]!)" }.joined(separator: ",")
+        if serialized == lastSentMicTuningBody {
+            Bridge.log("LIVE: 🎚️ Mic tuning unchanged this link, not resending: \(serialized)")
+            return
+        }
+
+        Bridge.log("LIVE: 🎚️ Sending mic tuning to glasses: \(body)")
+        sendMicTuningCommand("cs_mictun", body: body)
+        lastSentMicTuningBody = serialized
+    }
+
+    /// Ask the glasses what tuning they are actually running (sr_micst).
+    func requestMicTuningState() {
+        guard connectedPeripheral != nil, txCharacteristic != nil else {
+            Bridge.log("LIVE: Cannot send cs_micst - BLE write path not ready")
+            return
+        }
+        if !peerMicTuning {
+            Bridge.log("LIVE: mic_tuning cap not advertised; sending cs_micst anyway")
+        }
+        sendMicTuningCommand("cs_micst", body: [:])
+    }
+
+    /// Enable or disable the sr_micrms readout.
+    func setMicRmsTelemetry(_ enabled: Bool) {
+        guard connectedPeripheral != nil, txCharacteristic != nil, peerMicTuning else { return }
+        sendMicTuningCommand("cs_micrms", body: ["on": enabled ? 1 : 0])
+    }
+
+    /// Read the current wear state (sr_wrst). Always available.
+    @objc func queryWearState() {
+        sendWearCommandIfReady("cs_wrst", body: [:])
+    }
+
+    /// 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.
+    @objc func setWearReporting(_ enabled: Bool) {
+        sendWearCommandIfReady("cs_weartun", body: ["enabled": enabled ? 1 : 0])
+    }
+
+    /// Move the debounce vote. Negative means "leave this one alone".
+    @objc func setWearTuning(intervalMs: Int, count: Int, majority: Int) {
+        var body: [String: Any] = [:]
+        if intervalMs >= 0 { body["interval"] = intervalMs }
+        if count >= 0 { body["count"] = count }
+        if majority >= 0 { body["majority"] = majority }
+        guard !body.isEmpty else { return }
+        sendWearCommandIfReady("cs_weartun", body: body)
+    }
+
+    /// Ask what the poll loop is actually running (sr_weartun).
+    @objc func requestWearTuning() {
+        sendWearCommandIfReady("cs_wearst", body: [:])
+    }
+
+    /// Restore firmware defaults and disable reporting. Distinct from sending
+    /// the default vote values, which would leave reporting on.
+    @objc func resetWearTuning() {
+        sendWearCommandIfReady("cs_weartun", body: ["reset": 1])
+    }
+
+    private func sendWearCommandIfReady(_ name: String, body: [String: Any]) {
+        guard connectedPeripheral != nil, txCharacteristic != nil else {
+            Bridge.log("LIVE: Cannot send \(name) - BLE write path not ready")
+            return
+        }
+        if !peerWearTuning && name != "cs_wrst" {
+            Bridge.log("LIVE: wear_tuning cap not advertised; sending \(name) anyway")
+        }
+        sendMicTuningCommand(name, body: body)
+    }
+
+    private func sendMicTuningCommand(_ name: String, body: [String: Any]) {
+        do {
+            let bodyData = try JSONSerialization.data(withJSONObject: body)
+            guard let bodyString = String(data: bodyData, encoding: .utf8) else {
+                Bridge.log("LIVE: Failed to encode \(name) payload")
+                return
+            }
+            let command: [String: Any] = ["C": name, "V": 1, "B": bodyString]
+            if !sendRawK900Command(command, wakeUp: true) {
+                Bridge.log("LIVE: Failed to send \(name)")
+            }
+        } catch {
+            Bridge.log("LIVE: Error encoding \(name) payload: \(error)")
+        }
+    }
+
+    /// 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 func handleMicTuningState(_ body: [String: Any]) {
+        var state: [String: Any] = [:]
+        for name in Self.micTuningFields {
+            if let number = body[name] as? NSNumber {
+                state[name] = number.intValue
+            }
+        }
+        let generation = (body["gen"] as? NSNumber)?.intValue ?? 0
+        state["generation"] = generation
+        state["overridden"] = ((body["ovr"] as? NSNumber)?.intValue ?? 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 func handleWearTuningState(_ json: [String: Any], _ body: [String: Any]) {
+        let state: [String: Any] = [
+            "enabled": (k900JsonInt(body, "enabled") ?? 0) != 0,
+            "interval": k900JsonInt(body, "interval") ?? 0,
+            "count": k900JsonInt(body, "count") ?? 0,
+            "majority": k900JsonInt(body, "majority") ?? 0,
+            "generation": k900JsonInt(body, "gen") ?? 0,
+            "accepted": (k900JsonInt(json, "S") ?? 0) == 0,
+        ]
+        Bridge.sendWearTuningState(state)
     }
 
     func sendVoiceActivityDetectionSetting() {

package/ios/Source/sgcs/SGCManager.swift

@@ -228,6 +228,24 @@ protocol SGCManager {
 
     func sendLoudnessGateSetting()
 
+    // MARK: - Mic tuning (super-mode only)
+
+    func sendMicTuningSetting()
+    func requestMicTuningState()
+    func setMicRmsTelemetry(_ enabled: Bool)
+
+    // MARK: - Wear detection (super-mode only)
+
+    // These are protocol requirements, not extension-only members, on purpose:
+    // DeviceManager holds an `SGCManager?`, and a method that exists only in
+    // the extension is statically dispatched through that reference, so the
+    // no-op below would win over MentraLive's implementation.
+    func queryWearState()
+    func setWearReporting(_ enabled: Bool)
+    func setWearTuning(intervalMs: Int, count: Int, majority: Int)
+    func requestWearTuning()
+    func resetWearTuning()
+
     // MARK: - Version Info
 
     func requestVersionInfo()
@@ -417,6 +435,20 @@ extension SGCManager {
 
     func sendLoudnessGateSetting() {}
 
+    // MARK: - Mic tuning (default no-op — Mentra Live supports this)
+
+    func sendMicTuningSetting() {}
+    func requestMicTuningState() {}
+    func setMicRmsTelemetry(_: Bool) {}
+
+    // MARK: - Wear detection (default no-op — Mentra Live supports this)
+
+    func queryWearState() {}
+    func setWearReporting(_: Bool) {}
+    func setWearTuning(intervalMs _: Int, count _: Int, majority _: Int) {}
+    func requestWearTuning() {}
+    func resetWearTuning() {}
+
     /// Default no-op; Mentra Live and G2 override to handle phone-detected clock skew.
     func sendSetSystemTime(_: Int64) {
         Bridge.log("SGC: sendSetSystemTime not supported")

package/ios/Tests/WearTuningDispatchTests.swift

@@ -0,0 +1,51 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+/// Recording subclass used to prove wear methods dispatched through an
+/// `SGCManager?` hit MentraLive, not the extension no-op.
+@MainActor
+private final class RecordingMentraLive: MentraLive {
+    private(set) var calls: [String] = []
+
+    override func queryWearState() {
+        calls.append("queryWearState")
+    }
+
+    override func setWearReporting(_ enabled: Bool) {
+        calls.append("setWearReporting:\(enabled)")
+    }
+
+    override func setWearTuning(intervalMs: Int, count: Int, majority: Int) {
+        calls.append("setWearTuning:\(intervalMs),\(count),\(majority)")
+    }
+
+    override func requestWearTuning() {
+        calls.append("requestWearTuning")
+    }
+
+    override func resetWearTuning() {
+        calls.append("resetWearTuning")
+    }
+}
+
+@MainActor
+final class WearTuningDispatchTests: XCTestCase {
+    func testWearMethodsDispatchThroughSGCManagerReference() {
+        let live = RecordingMentraLive()
+        let sgc: (any SGCManager)? = live
+
+        sgc?.queryWearState()
+        sgc?.setWearReporting(true)
+        sgc?.setWearTuning(intervalMs: 300, count: 5, majority: 4)
+        sgc?.requestWearTuning()
+        sgc?.resetWearTuning()
+
+        XCTAssertEqual(live.calls, [
+            "queryWearState",
+            "setWearReporting:true",
+            "setWearTuning:300,5,4",
+            "requestWearTuning",
+            "resetWearTuning",
+        ])
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "3.2.1-dev.278",
+  "version": "3.2.1-dev.279",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",
@@ -114,7 +114,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@mentra/cloud-protocol": "3.2.1-dev.278"
+    "@mentra/cloud-protocol": "3.2.1-dev.279"
   },
   "devDependencies": {
     "@types/node": "^25.9.3",

package/src/BluetoothSdk.types.ts

@@ -481,6 +481,84 @@ export type SwitchStatusEvent = {
   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"
@@ -1066,6 +1144,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
@@ -1226,6 +1308,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
@@ -1701,6 +1787,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; height: number; fps: number}
   button_video_width: number

package/src/_private/BluetoothSdkModule.ts

@@ -33,6 +33,7 @@ import {
   NativePhoneNotification,
   NativeNotificationConfig,
   NativeNotificationStatus,
+  MicTuning,
   ObservableStoreCategory,
   OtaQueryResult,
   OtaStartAckEvent,
@@ -143,6 +144,36 @@ declare class BluetoothSdkNativeModule extends NativeModule<BluetoothSdkModuleEv
   setVoiceActivityDetectionEnabled(enabled: boolean): Promise<void>
   /** Mentra Live center-mic loudness / Barrier gate (cs_swit type 10). */
   setLoudnessGateEnabled(enabled: boolean): Promise<void>
+  /**
+   * Mentra Live mic tuning. `null` clears every override and returns the
+   * glasses to firmware defaults.
+   *
+   * Deliberately absent from the public SDK surface: it is a super-mode
+   * calibration aid whose values only make sense next to a live RMS readout.
+   */
+  setMicTuning(tuning: MicTuning | null): Promise<void>
+  /**
+   * Ask the glasses to report the tuning they are actually running. The answer
+   * arrives as a `mic_tuning_state` event, which is also emitted unprompted
+   * after every set, so a screen that subscribes on mount and calls this on
+   * focus never has to guess.
+   */
+  requestMicTuningState(): Promise<void>
+  /** Enable or disable the `mic_rms` readout. Auto-disabled on disconnect. */
+  setMicRmsTelemetry(enabled: boolean): Promise<void>
+  /**
+   * Mentra Live wear detection. Internal / Super Mode only.
+   *
+   * Reporting is RAM-only on the glasses and must not go through `cs_swit`
+   * type 1 (that bit is NV-backed). `resetWearTuning` both restores the
+   * firmware vote defaults and turns reporting off.
+   */
+  queryWearState(): Promise<void>
+  setWearReporting(enabled: boolean): Promise<void>
+  /** Negative values leave that field unchanged. */
+  setWearTuning(intervalMs: number, count: number, majority: number): Promise<void>
+  requestWearTuning(): Promise<void>
+  resetWearTuning(): Promise<void>
   /**
    * @deprecated Sticky action-button photo presets are deprecated. Prefer per-request
    * `requestPhoto(...)` options (e.g. `mode: "text"` for text sensor size/crop).
@@ -546,6 +577,22 @@ NativeBluetoothSdkModule.setLoudnessGateEnabled = function (enabled: boolean) {
   return this.updateBluetoothSettings({loudness_gate_enabled: enabled})
 }
 
+NativeBluetoothSdkModule.setMicTuning = function (tuning: MicTuning | null) {
+  // `{}` rather than null: the store drops null writes, and the native side
+  // reads an empty object as "no overrides" and sends an explicit reset.
+  return this.updateBluetoothSettings({mic_tuning: tuning ?? {}})
+}
+
+const nativeMicModule = NativeBluetoothSdkModule as unknown as Record<string, unknown>
+NativeBluetoothSdkModule.requestMicTuningState = bindNativeMethod<() => Promise<void>>(
+  nativeMicModule,
+  "requestMicTuningState",
+)
+NativeBluetoothSdkModule.setMicRmsTelemetry = bindNativeMethod<(enabled: boolean) => Promise<void>>(
+  nativeMicModule,
+  "setMicRmsTelemetry",
+)
+
 const nativeSetCameraFov = bindNativeMethod<(fov: CameraFovSetting) => MaybePromise<CameraFovResult>>(
   NativeBluetoothSdkModule as unknown as Record<string, unknown>,
   "setCameraFov",
@@ -678,5 +725,20 @@ NativeBluetoothSdkModule.startStream = function (params: StreamStartRequest) {
   return nativeStartStream(streamRequestParamsForNative(params) as unknown as StreamStartRequest)
 }
 
+const nativeWearModule = NativeBluetoothSdkModule as unknown as Record<string, unknown>
+NativeBluetoothSdkModule.queryWearState = bindNativeMethod<() => Promise<void>>(nativeWearModule, "queryWearState")
+NativeBluetoothSdkModule.setWearReporting = bindNativeMethod<(enabled: boolean) => Promise<void>>(
+  nativeWearModule,
+  "setWearReporting",
+)
+NativeBluetoothSdkModule.setWearTuning = bindNativeMethod<
+  (intervalMs: number, count: number, majority: number) => Promise<void>
+>(nativeWearModule, "setWearTuning")
+NativeBluetoothSdkModule.requestWearTuning = bindNativeMethod<() => Promise<void>>(
+  nativeWearModule,
+  "requestWearTuning",
+)
+NativeBluetoothSdkModule.resetWearTuning = bindNativeMethod<() => Promise<void>>(nativeWearModule, "resetWearTuning")
+
 export default NativeBluetoothSdkModule
 export const BluetoothSdk = NativeBluetoothSdkModule as BluetoothSdkInternalModule

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface BluetoothSdkReleaseMetadata {
 export const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "3.2.1",
-  "releaseIdentity": "3.2.1-dev.278",
-  "releaseSetId": "mentra-3.2.1-dev.278",
-  "sourceCommit": "3fdfe01c096c79797d51fdef608ddb8ed91e14c3",
-  "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-dev.278.json",
-  "otaManifestSha256": "1ab2a29845eb5b865b15ad16e2006d34a2f9590dcade5bf085722c4aba0ca978"
+  "releaseIdentity": "3.2.1-dev.279",
+  "releaseSetId": "mentra-3.2.1-dev.279",
+  "sourceCommit": "b89b07413c06947f1a2f4a321ce23927eaebd4e4",
+  "otaManifestUrl": "https://artifactscdn.mentraglass.com/Mentra-Community/MentraOS/releases/mentra-builds-v3.2.1/mentra-live-ota-3.2.1-dev.279.json",
+  "otaManifestSha256": "725cccaec20e39be8f75dbe1e511092aa4812ab46cade44a583843282f0c0eb3"
 })