feat(voice): mute microphone from AirPods controls

src-tauri/Cargo.toml

@@ -21,6 +21,9 @@ exclude = ["plugins/app-test-driver"]
 tauri-build = { version = "2", features = [] }
 cc = "1"
 
+[target.'cfg(target_os = "macos")'.build-dependencies]
+swift-rs = { version = "1.0.7", features = ["build"] }
+
 [dependencies]
 anyhow = "1"
 base64 = "0.22"
@@ -109,6 +112,7 @@ windows-sys = { version = "0.59", features = [
 block2 = "0.6"
 objc2 = "0.6"
 objc2-app-kit = { version = "0.3.2", features = ["NSApplication", "NSImage", "NSMenu", "NSMenuItem", "NSAlert", "NSButton", "NSControl", "NSCell", "NSResponder", "NSView"] }
+objc2-avf-audio = { version = "0.3.2", features = ["AVAudioApplication", "block2"] }
 objc2-foundation = { version = "0.3.2", features = ["NSDictionary", "NSError", "NSFileManager", "NSObject", "NSProcessInfo", "NSString", "NSURL"] }
 objc2-user-notifications = "0.3.2"
 rodio = { version = "0.22", default-features = false, features = ["playback"] }

src-tauri/build.rs

@@ -18,7 +18,11 @@ fn main() {
         for framework in ["Foundation", "AVFoundation", "AudioToolbox", "CoreAudio"] {
             println!("cargo:rustc-link-lib=framework={framework}");
         }
+        if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("macos") {
+            swift_rs::SwiftLinker::new("14.0")
+                .with_package("BerdAirPodsBridge", "swift/BerdAirPodsBridge")
+                .link();
+        }
     }
-
     tauri_build::build()
 }

src-tauri/src/commands/mod.rs

@@ -31,6 +31,7 @@ pub mod local_mcp_inventory;
 pub mod message_queues;
 pub mod migration;
 pub mod model_setup;
+mod native_input_mute;
 pub mod native_voice;
 pub mod notifications;
 #[cfg(feature = "block-voice-dictation")]

src-tauri/src/commands/native_input_mute.rs

@@ -0,0 +1,170 @@
+use std::sync::{
+    atomic::{AtomicBool, AtomicU64, Ordering},
+    Arc,
+};
+
+pub fn start<F>(input_muted: &Arc<AtomicBool>, mute_epoch: &Arc<AtomicU64>, on_change: F) -> bool
+where
+    F: Fn(bool) + Send + Sync + 'static,
+{
+    clear(input_muted);
+
+    #[cfg(target_os = "macos")]
+    return match macos::install(Arc::clone(input_muted), Arc::clone(mute_epoch), on_change) {
+        Ok(()) => true,
+        Err(error) => {
+            log::info!("AirPods input mute listener is unavailable: {error}");
+            false
+        }
+    };
+
+    #[cfg(not(target_os = "macos"))]
+    {
+        let _ = (mute_epoch, on_change);
+        false
+    }
+}
+
+pub fn stop(input_muted: &Arc<AtomicBool>) {
+    clear(input_muted);
+
+    #[cfg(target_os = "macos")]
+    if let Err(error) = macos::uninstall() {
+        log::info!("Could not stop the AirPods input mute listener: {error}");
+    }
+}
+
+pub fn set_muted(
+    input_muted: &AtomicBool,
+    mute_epoch: &AtomicU64,
+    muted: bool,
+) -> Result<(), String> {
+    #[cfg(target_os = "macos")]
+    {
+        macos::set_muted(muted)?;
+        apply_change(input_muted, mute_epoch, muted, &|_| {});
+        Ok(())
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    {
+        let _ = (input_muted, mute_epoch, muted);
+        Err("native microphone mute is only available on macOS".to_string())
+    }
+}
+
+fn clear(input_muted: &AtomicBool) {
+    input_muted.store(false, Ordering::Release);
+}
+
+#[cfg(any(target_os = "macos", test))]
+fn apply_change(
+    input_muted: &AtomicBool,
+    mute_epoch: &AtomicU64,
+    muted: bool,
+    on_change: &dyn Fn(bool),
+) {
+    if input_muted.swap(muted, Ordering::AcqRel) != muted {
+        if muted {
+            mute_epoch.fetch_add(1, Ordering::AcqRel);
+        }
+        on_change(muted);
+    }
+}
+
+#[cfg(target_os = "macos")]
+mod macos {
+    use super::*;
+    use block2::RcBlock;
+    use objc2::runtime::Bool;
+    use objc2_avf_audio::AVAudioApplication;
+
+    extern "C" {
+        fn berd_airpods_capture_start() -> bool;
+        fn berd_airpods_capture_stop();
+    }
+
+    pub fn install<F>(
+        input_muted: Arc<AtomicBool>,
+        mute_epoch: Arc<AtomicU64>,
+        on_change: F,
+    ) -> Result<(), String>
+    where
+        F: Fn(bool) + Send + Sync + 'static,
+    {
+        // SAFETY: Berd's minimum macOS version is 14.0, where
+        // AVAudioApplication and these selectors are public API.
+        let application = unsafe { AVAudioApplication::sharedInstance() };
+        let handler = RcBlock::new(move |muted: Bool| {
+            let muted = muted.as_bool();
+            apply_change(&input_muted, &mute_epoch, muted, &|muted| {
+                log::info!("AirPods input mute changed muted={muted}");
+                on_change(muted);
+            });
+            Bool::YES
+        });
+        // SAFETY: The block has the generated AVFAudio signature. The API
+        // copies and retains it until a later registration or cancellation.
+        if let Err(error) =
+            unsafe { application.setInputMuteStateChangeHandler_error(Some(&handler)) }
+        {
+            return Err(error.localizedDescription().to_string());
+        }
+        if let Err(error) = unsafe { application.setInputMuted_error(false) } {
+            let _ = unsafe { application.setInputMuteStateChangeHandler_error(None) };
+            return Err(error.localizedDescription().to_string());
+        }
+        // SAFETY: The Swift bridge owns one process-global AVAudioEngine and
+        // exposes a C-compatible lifecycle API.
+        if !unsafe { berd_airpods_capture_start() } {
+            let _ = unsafe { application.setInputMuteStateChangeHandler_error(None) };
+            return Err("macOS microphone capture could not start".to_string());
+        }
+        log::info!("AirPods input mute listener started");
+        Ok(())
+    }
+
+    pub fn uninstall() -> Result<(), String> {
+        // SAFETY: Berd targets macOS 14+, and nil is the documented way to
+        // cancel the process-wide handler at the end of a call lifecycle.
+        let application = unsafe { AVAudioApplication::sharedInstance() };
+        // Do not leave another Berd microphone feature inheriting the voice
+        // conversation's last input-mute state after its handler is gone.
+        let reset_result = unsafe { application.setInputMuted_error(false) }
+            .map_err(|error| error.localizedDescription().to_string());
+        let handler_result = unsafe { application.setInputMuteStateChangeHandler_error(None) }
+            .map_err(|error| error.localizedDescription().to_string());
+        unsafe { berd_airpods_capture_stop() };
+        reset_result.and(handler_result)
+    }
+
+    pub fn set_muted(muted: bool) -> Result<(), String> {
+        let application = unsafe { AVAudioApplication::sharedInstance() };
+        unsafe { application.setInputMuted_error(muted) }
+            .map_err(|error| error.localizedDescription().to_string())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn lifecycle_boundary_clears_mute() {
+        let input_muted = Arc::new(AtomicBool::new(true));
+        clear(&input_muted);
+        assert!(!input_muted.load(Ordering::Acquire));
+    }
+
+    #[test]
+    fn mute_edge_advances_epoch_even_after_immediate_unmute() {
+        let input_muted = AtomicBool::new(false);
+        let mute_epoch = AtomicU64::new(0);
+
+        apply_change(&input_muted, &mute_epoch, true, &|_| {});
+        apply_change(&input_muted, &mute_epoch, false, &|_| {});
+
+        assert!(!input_muted.load(Ordering::Acquire));
+        assert_eq!(mute_epoch.load(Ordering::Acquire), 1);
+    }
+}