refactor: centralize notification policy with explicit skip conditions (#3513)

yujonglee · devin-ai-integration[bot] · web-flow · commit 6dfe9e7f3135 · 2026-02-01T19:08:06.000+09:00
Co-authored-by: yujonglee &lt;yujonglee.dev@gmail.com&gt;
Co-authored-by: Devin AI &lt;158243242+devin-ai-integration[bot]@users.noreply.github.com&gt;
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/notification-interface/src/lib.rs b/crates/notification-interface/src/lib.rs
@@ -1,3 +1,5 @@
+use std::collections::BTreeSet;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, specta::Type)]
 pub enum NotificationEvent {
     Confirm,
@@ -6,6 +8,63 @@ pub enum NotificationEvent {
     Timeout,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum NotificationKey {
+    MicStarted { apps: BTreeSet<String> },
+    MicStopped { apps: BTreeSet<String> },
+    CalendarEvent { event_id: String },
+    Custom(String),
+}
+
+impl NotificationKey {
+    pub fn mic_started(app_bundle_ids: impl IntoIterator<Item = String>) -> Self {
+        Self::MicStarted {
+            apps: app_bundle_ids.into_iter().collect(),
+        }
+    }
+
+    pub fn mic_stopped(app_bundle_ids: impl IntoIterator<Item = String>) -> Self {
+        Self::MicStopped {
+            apps: app_bundle_ids.into_iter().collect(),
+        }
+    }
+
+    pub fn calendar_event(event_id: impl Into<String>) -> Self {
+        Self::CalendarEvent {
+            event_id: event_id.into(),
+        }
+    }
+
+    pub fn to_dedup_key(&self) -> String {
+        match self {
+            Self::MicStarted { apps } => {
+                let sorted: Vec<_> = apps.iter().cloned().collect();
+                format!("mic-started:{}", sorted.join(","))
+            }
+            Self::MicStopped { apps } => {
+                let sorted: Vec<_> = apps.iter().cloned().collect();
+                format!("mic-stopped:{}", sorted.join(","))
+            }
+            Self::CalendarEvent { event_id } => {
+                format!("event:{event_id}")
+            }
+            Self::Custom(s) => s.clone(),
+        }
+    }
+}
+
+impl From<String> for NotificationKey {
+    fn from(s: String) -> Self {
+        Self::Custom(s)
+    }
+}
+
+impl From<&str> for NotificationKey {
+    fn from(s: &str) -> Self {
+        Self::Custom(s.to_string())
+    }
+}
+
 #[derive(
     Debug, Clone, Copy, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize, specta::Type,
 )]
diff --git a/plugins/detect/Cargo.toml b/plugins/detect/Cargo.toml
@@ -22,6 +22,8 @@ specta-typescript = { workspace = true }
 [dependencies]
 hypr-detect = { workspace = true, features = ["mic", "list", "language", "sleep"] }
 hypr-host = { workspace = true }
+hypr-notification-interface = { workspace = true }
+tauri-plugin-listener = { workspace = true }
 
 tauri = { workspace = true, features = ["specta", "test"] }
 tauri-plugin-windows = { workspace = true }
diff --git a/plugins/detect/src/ext.rs b/plugins/detect/src/ext.rs
@@ -13,19 +13,19 @@ impl<'a, R: tauri::Runtime, M: tauri::Manager<R>> Detect<'a, R, M> {
     }
 
     pub fn list_default_ignored_bundle_ids(&self) -> Vec<String> {
-        crate::handler::default_ignored_bundle_ids()
+        crate::policy::default_ignored_bundle_ids()
     }
 
     pub async fn set_ignored_bundle_ids(&self, bundle_ids: Vec<String>) {
         let state = self.manager.state::<crate::SharedState>();
         let mut state_guard = state.lock().await;
-        state_guard.ignored_bundle_ids = bundle_ids;
+        state_guard.policy.user_ignored_bundle_ids = bundle_ids;
     }
 
     pub async fn set_respect_do_not_disturb(&self, enabled: bool) {
         let state = self.manager.state::<crate::SharedState>();
         let mut state_guard = state.lock().await;
-        state_guard.respect_do_not_disturb = enabled;
+        state_guard.policy.respect_dnd = enabled;
     }
 }
 
diff --git a/plugins/detect/src/handler.rs b/plugins/detect/src/handler.rs
@@ -1,113 +1,28 @@
 use tauri::{AppHandle, EventTarget, Manager, Runtime};
+use tauri_plugin_listener::ListenerPluginExt;
 use tauri_plugin_windows::WindowImpl;
 use tauri_specta::Event;
 
-use crate::{DetectEvent, SharedState, dnd};
-
-pub(crate) fn default_ignored_bundle_ids() -> Vec<String> {
-    let hyprnote = [
-        "com.hyprnote.dev",
-        "com.hyprnote.stable",
-        "com.hyprnote.nightly",
-        "com.hyprnote.staging",
-    ];
-
-    let dictation_apps = [
-        "com.electron.wispr-flow",
-        "com.seewillow.WillowMac",
-        "com.superduper.superwhisper",
-        "com.prakashjoshipax.VoiceInk",
-        "com.goodsnooze.macwhisper",
-        "com.descript.beachcube",
-        "com.apple.VoiceMemos",
-        "com.electron.aqua-voice",
-    ];
-
-    let ides = [
-        "dev.warp.Warp-Stable",
-        "com.exafunction.windsurf",
-        "com.microsoft.VSCode",
-        "com.todesktop.230313mzl4w4u92",
-    ];
-
-    let screen_recording = [
-        "so.cap.desktop",
-        "com.timpler.screenstudio",
-        "com.loom.desktop",
-        "com.obsproject.obs-studio",
-    ];
-
-    let ai_assistants = ["com.openai.chat", "com.anthropic.claudefordesktop"];
-
-    let other = [
-        "com.raycast.macos",
-        "com.apple.garageband10",
-        "com.apple.Sound-Settings.extension",
-    ];
-
-    dictation_apps
-        .into_iter()
-        .chain(hyprnote)
-        .chain(ides)
-        .chain(screen_recording)
-        .chain(ai_assistants)
-        .chain(other)
-        .map(String::from)
-        .collect()
-}
+use crate::{
+    DetectEvent, SharedState, dnd,
+    policy::{MicEventType, PolicyContext},
+};
 
 pub async fn setup<R: Runtime>(app: &AppHandle<R>) -> Result<(), Box<dyn std::error::Error>> {
     let app_handle = app.app_handle().clone();
     let callback = hypr_detect::new_callback(move |event| {
-        let state = app_handle.state::<SharedState>();
+        let app_handle_clone = app_handle.clone();
 
         match event {
             hypr_detect::DetectEvent::MicStarted(apps) => {
-                let state_guard = state.blocking_lock();
-
-                if state_guard.respect_do_not_disturb && dnd::is_do_not_disturb() {
-                    tracing::info!(reason = "respect_do_not_disturb", "skip_notification");
-                    return;
-                }
-
-                let filtered_apps = filter_apps(apps, &state_guard.ignored_bundle_ids);
-                drop(state_guard);
-
-                if filtered_apps.is_empty() {
-                    tracing::info!(reason = "all_apps_filtered", "skip_notification");
-                    return;
-                }
-
-                emit_to_main(
-                    &app_handle,
-                    DetectEvent::MicStarted {
-                        key: uuid::Uuid::new_v4().to_string(),
-                        apps: filtered_apps,
-                    },
-                );
+                tauri::async_runtime::spawn(async move {
+                    handle_mic_started(&app_handle_clone, apps).await;
+                });
             }
             hypr_detect::DetectEvent::MicStopped(apps) => {
-                let state_guard = state.blocking_lock();
-
-                if state_guard.respect_do_not_disturb && dnd::is_do_not_disturb() {
-                    tracing::info!(reason = "respect_do_not_disturb", "skip_mic_stopped");
-                    return;
-                }
-
-                let filtered_apps = filter_apps(apps, &state_guard.ignored_bundle_ids);
-                drop(state_guard);
-
-                if filtered_apps.is_empty() {
-                    tracing::info!(reason = "all_apps_filtered", "skip_mic_stopped");
-                    return;
-                }
-
-                emit_to_main(
-                    &app_handle,
-                    DetectEvent::MicStopped {
-                        apps: filtered_apps,
-                    },
-                );
+                tauri::async_runtime::spawn(async move {
+                    handle_mic_stopped(&app_handle_clone, apps).await;
+                });
             }
             #[cfg(all(target_os = "macos", feature = "zoom"))]
             hypr_detect::DetectEvent::ZoomMuteStateChanged { value } => {
@@ -128,15 +43,87 @@ pub async fn setup<R: Runtime>(app: &AppHandle<R>) -> Result<(), Box<dyn std::er
     Ok(())
 }
 
-fn filter_apps(
+async fn handle_mic_started<R: Runtime>(
+    app_handle: &AppHandle<R>,
+    apps: Vec<hypr_detect::InstalledApp>,
+) {
+    let is_listening = {
+        let listener_state = app_handle.listener().get_state().await;
+        matches!(
+            listener_state,
+            tauri_plugin_listener::fsm::State::Active
+                | tauri_plugin_listener::fsm::State::Finalizing
+        )
+    };
+
+    let state = app_handle.state::<SharedState>();
+    let state_guard = state.lock().await;
+
+    let is_dnd = dnd::is_do_not_disturb();
+
+    let ctx = PolicyContext {
+        apps: &apps,
+        is_listening,
+        is_dnd,
+        event_type: MicEventType::Started,
+    };
+
+    match state_guard.policy.evaluate(&ctx) {
+        Ok(result) => {
+            drop(state_guard);
+            emit_to_main(
+                app_handle,
+                DetectEvent::MicStarted {
+                    key: result.dedup_key,
+                    apps: result.filtered_apps,
+                },
+            );
+        }
+        Err(reason) => {
+            tracing::info!(?reason, "skip_notification");
+        }
+    }
+}
+
+async fn handle_mic_stopped<R: Runtime>(
+    app_handle: &AppHandle<R>,
     apps: Vec<hypr_detect::InstalledApp>,
-    ignored_bundle_ids: &[String],
-) -> Vec<hypr_detect::InstalledApp> {
-    let default_ignored = default_ignored_bundle_ids();
-    apps.into_iter()
-        .filter(|app| !ignored_bundle_ids.contains(&app.id))
-        .filter(|app| !default_ignored.contains(&app.id))
-        .collect()
+) {
+    let is_listening = {
+        let listener_state = app_handle.listener().get_state().await;
+        matches!(
+            listener_state,
+            tauri_plugin_listener::fsm::State::Active
+                | tauri_plugin_listener::fsm::State::Finalizing
+        )
+    };
+
+    let state = app_handle.state::<SharedState>();
+    let state_guard = state.lock().await;
+
+    let is_dnd = dnd::is_do_not_disturb();
+
+    let ctx = PolicyContext {
+        apps: &apps,
+        is_listening,
+        is_dnd,
+        event_type: MicEventType::Stopped,
+    };
+
+    match state_guard.policy.evaluate(&ctx) {
+        Ok(result) => {
+            drop(state_guard);
+            emit_to_main(
+                app_handle,
+                DetectEvent::MicStopped {
+                    apps: result.filtered_apps,
+                },
+            );
+        }
+        Err(reason) => {
+            tracing::info!(?reason, "skip_mic_stopped");
+        }
+    }
 }
 
 fn emit_to_main<R: Runtime>(app_handle: &AppHandle<R>, event: DetectEvent) {
diff --git a/plugins/detect/src/lib.rs b/plugins/detect/src/lib.rs
@@ -7,22 +7,31 @@ mod error;
 mod events;
 mod ext;
 mod handler;
+mod policy;
 
 pub use dnd::*;
 pub use error::*;
 pub use events::*;
 pub use ext::*;
+pub use policy::*;
 
 const PLUGIN_NAME: &str = "detect";
 
 pub type SharedState = Mutex<State>;
 
-#[derive(Default)]
 pub struct State {
     #[allow(dead_code)]
     pub(crate) detector: hypr_detect::Detector,
-    pub(crate) ignored_bundle_ids: Vec<String>,
-    pub(crate) respect_do_not_disturb: bool,
+    pub(crate) policy: policy::MicNotificationPolicy,
+}
+
+impl Default for State {
+    fn default() -> Self {
+        Self {
+            detector: hypr_detect::Detector::default(),
+            policy: policy::MicNotificationPolicy::default(),
+        }
+    }
 }
 
 fn make_specta_builder<R: tauri::Runtime>() -> tauri_specta::Builder<R> {
diff --git a/plugins/detect/src/policy.rs b/plugins/detect/src/policy.rs

Original file line number	Diff line number	Diff line change
`@@ -13,19 +13,19 @@ impl<'a, R: tauri::Runtime, M: tauri::Manager<R>> Detect<'a, R, M> {`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`pub fn list_default_ignored_bundle_ids(&self) -> Vec<String> {`
`16`		`- crate::handler::default_ignored_bundle_ids()`
	`16`	`+ crate::policy::default_ignored_bundle_ids()`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`pub async fn set_ignored_bundle_ids(&self, bundle_ids: Vec<String>) {`
`20`	`20`	`let state = self.manager.state::<crate::SharedState>();`
`21`	`21`	`let mut state_guard = state.lock().await;`
`22`		`- state_guard.ignored_bundle_ids = bundle_ids;`
	`22`	`+ state_guard.policy.user_ignored_bundle_ids = bundle_ids;`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`pub async fn set_respect_do_not_disturb(&self, enabled: bool) {`
`26`	`26`	`let state = self.manager.state::<crate::SharedState>();`
`27`	`27`	`let mut state_guard = state.lock().await;`
`28`		`- state_guard.respect_do_not_disturb = enabled;`
	`28`	`+ state_guard.policy.respect_dnd = enabled;`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`