use polling, throttle cursor detection and device re-mute

Author: brettinternet

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "mic-mute"
 description = "System-wide mic mute for macOS"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 authors = ["Brett Gardiner"]
 license = "MIT"

Cargo.toml

@@ -16,7 +16,7 @@ Mute with <kbd>Cmd</kbd> <kbd>Shift</kbd> <kbd>A</kbd> or from the system tray d
   - [x] Mute input devices
     - Note: Some virtual devices may be unable to mute for now
   - [x] Provide global hotkey muting
-  - [ ] Polls for new devices to mute while active
+  - [x] Poll new devices to mute while microphones should be off
 - Visual confirmation of mute status
   - [x] Show microphone mute status in system tray
   - [x] Show microphone mute status in small popup window

README.md

@@ -1,15 +1,19 @@
-use crate::{mic::MicController, ui::UI};
+use crate::mic::MicController;
+use crate::ui::UI;
+use crate::utils::Throttle;
 use async_std::task;
 use global_hotkey::GlobalHotKeyEvent;
 use log::trace;
 use std::sync::{Arc, RwLock};
 use std::time::Duration;
 use tao::event::Event;
 use tao::event_loop::{ControlFlow, EventLoop, EventLoopProxy};
-use tao::platform::macos::ActivationPolicy;
-use tao::platform::macos::EventLoopExtMacOS;
+use tao::platform::macos::{ActivationPolicy, EventLoopExtMacOS};
 use tray_icon::menu::MenuEvent;
 
+// Timeout for mouse detect and device re-mute
+const THROTTLE_TIMEOUT_MILLIS: u64 = 200;
+
 #[derive(Debug)]
 pub enum Message {
     HidePopup,
@@ -28,16 +32,20 @@ pub struct EventIds {
     pub shortcut_shift_meta_a: u32,
 }
 
-fn toggle_mic(
+fn update_mic(
     ui: Arc<RwLock<UI>>,
     controller: Arc<RwLock<MicController>>,
     proxy: EventLoopProxyMessage,
+    toggle: bool,
 ) {
     let mut controller = controller.write().unwrap();
-    controller.toggle(None).unwrap();
-    let mut ui = ui.write().unwrap();
-    ui.update(controller.muted).unwrap();
-    if !controller.muted {
+    if toggle || controller.muted {
+        let state = if toggle { None } else { Some(controller.muted) };
+        controller.toggle(state).unwrap();
+        let mut ui = ui.write().unwrap();
+        ui.update(controller.muted).unwrap();
+    }
+    if toggle && !controller.muted {
         task::spawn(async move {
             task::sleep(Duration::from_secs(1)).await;
             proxy.send_event(Message::HidePopup).unwrap();
@@ -57,11 +65,13 @@ pub fn start(
         shortcut_shift_meta_a,
     } = event_ids;
 
+    let mut throttle = Throttle::new(Duration::from_millis(THROTTLE_TIMEOUT_MILLIS));
+
     trace!("Starting event loop");
     let proxy = event_loop.create_proxy();
     event_loop.set_activation_policy(ActivationPolicy::Accessory);
     event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+        *control_flow = ControlFlow::Poll;
 
         match event {
             Event::UserEvent(Message::HidePopup) => {
@@ -71,13 +81,13 @@ pub fn start(
                     ui.hide_popup().unwrap();
                 }
             }
-            Event::WindowEvent { .. } => {
-                // println!("event: {:?}", event);
-            }
             _ => {
-                // trace!("event: {:?}", event);
-                let mut ui = ui.write().unwrap();
-                ui.detect().unwrap();
+                if throttle.available() {
+                    update_mic(ui.clone(), controller.clone(), proxy.clone(), false);
+                    let mut ui = ui.write().unwrap();
+                    ui.detect().unwrap();
+                    throttle.accept().unwrap_or(());
+                }
             }
         };
 
@@ -92,7 +102,7 @@ pub fn start(
                 }
                 MenuEvent { id } if id == button_toggle_mute => {
                     trace!("Toggle mic tray menu item selected");
-                    toggle_mic(ui.clone(), controller.clone(), proxy.clone());
+                    update_mic(ui.clone(), controller.clone(), proxy.clone(), true);
                 }
                 _ => {}
             }
@@ -101,7 +111,7 @@ pub fn start(
         if let Ok(event) = GlobalHotKeyEvent::receiver().try_recv() {
             if shortcut_shift_meta_a == event.id {
                 trace!("Toggle mic shortcut activated");
-                toggle_mic(ui.clone(), controller.clone(), proxy.clone());
+                update_mic(ui.clone(), controller.clone(), proxy.clone(), true);
             }
         }
     });

src/event_loop.rs

@@ -12,14 +12,13 @@ mod utils;
 #[macro_use]
 extern crate objc;
 
+use crate::config::AppVars;
+use crate::event_loop::start;
+use crate::mic::MicController;
+use crate::ui::UI;
+use crate::utils::arc_lock;
 use env_logger::{Builder, Env};
-use event_loop::start;
 use log::{info, trace};
-use mic::MicController;
-use ui::UI;
-use utils::arc_lock;
-
-use crate::config::AppVars;
 
 fn main() {
     Builder::from_env(Env::default().default_filter_or("trace")).init();

src/main.rs

@@ -1,5 +1,9 @@
 use libc::c_void;
-use std::sync::{Arc, RwLock};
+use std::{
+    collections::VecDeque,
+    sync::{Arc, RwLock},
+    time::{Duration, Instant},
+};
 
 type CGFloat = f64;
 
@@ -22,15 +26,53 @@ pub fn get_cursor_pos() -> Option<(i32, i32)> {
         CFRelease(e);
         Some((point.x as _, point.y as _))
     }
-    // let mut pt: NSPoint = unsafe { msg_send![class!(NSEvent), mouseLocation] };
-    // let screen: id = unsafe { msg_send![class!(NSScreen), currentScreenForMouseLocation] };
-    // let frame: NSRect = unsafe { msg_send![screen, frame] };
-    // pt.x -= frame.origin.x;
-    // pt.y -= frame.origin.y;
-    // Some((pt.x as _, pt.y as _))
 }
 
 pub fn arc_lock<T>(value: T) -> Arc<RwLock<T>> {
     let rwlock = RwLock::new(value);
     Arc::new(rwlock)
 }
+
+// Modified from https://github.com/SOF3/throttle
+pub struct Throttle {
+    timeout: Duration,
+    deque: VecDeque<Instant>,
+}
+
+impl Throttle {
+    pub fn new(timeout: Duration) -> Throttle {
+        Throttle {
+            timeout,
+            deque: Default::default(),
+        }
+    }
+
+    fn flush(&mut self) {
+        while let Some(first) = self.deque.front() {
+            if first.elapsed() >= self.timeout.clone() {
+                self.deque.pop_front();
+            } else {
+                break;
+            }
+        }
+    }
+
+    pub fn size(&mut self) -> usize {
+        self.flush();
+        self.deque.len()
+    }
+
+    pub fn available(&mut self) -> bool {
+        self.size() < 1
+    }
+
+    pub fn accept(&mut self) -> Result<(), Instant> {
+        self.flush();
+        if self.deque.len() >= 1 {
+            return Err(self.deque.front().unwrap().clone() + self.timeout.clone());
+        }
+
+        self.deque.push_back(Instant::now());
+        Ok(())
+    }
+}