(hotfix) Respect notification detect setting from rust side (#4279)

Author: yujonglee

Cargo.lock

@@ -1,7 +1,6 @@
 import React, { createContext, useContext, useEffect, useRef } from "react";
 import { useStore } from "zustand";
 import { useShallow } from "zustand/shallow";
-import { useConfigValue } from "~/shared/config";
 import * as main from "~/store/tinybase/store/main";
 import {
   createListenerStore,
@@ -79,30 +78,20 @@ function getNearbyEvents(
 const useHandleDetectEvents = (store: ListenerStore) => {
   const stop = useStore(store, (state) => state.stop);
   const setMuted = useStore(store, (state) => state.setMuted);
-  const notificationDetectEnabled = useConfigValue("notification_detect");
   const tinybaseStore = main.UI.useStore(main.STORE_ID);
 
   const tinybaseStoreRef = useRef(tinybaseStore);
   useEffect(() => {
     tinybaseStoreRef.current = tinybaseStore;
   }, [tinybaseStore]);
 
-  const notificationDetectEnabledRef = useRef(notificationDetectEnabled);
-  useEffect(() => {
-    notificationDetectEnabledRef.current = notificationDetectEnabled;
-  }, [notificationDetectEnabled]);
-
   useEffect(() => {
     let unlisten: (() => void) | undefined;
     let cancelled = false;
 
     detectEvents.detectEvent
       .listen(({ payload }) => {
         if (payload.type === "micDetected") {
-          if (!notificationDetectEnabledRef.current) {
-            return;
-          }
-
           if (store.getState().live.status === "active") {
             return;
           }

apps/desktop/src/stt/contexts.tsx

@@ -12,12 +12,15 @@ default = ["zoom", "sleep"]
 zoom = ["hypr-detect/zoom"]
 language = ["hypr-detect/language"]
 sleep = ["hypr-detect/sleep"]
+test-support = []
 
 [build-dependencies]
 tauri-plugin = { workspace = true, features = ["build"] }
 
 [dev-dependencies]
+hypr-detect = { workspace = true, features = ["mic"] }
 specta-typescript = { workspace = true }
+tauri-plugin-detect = { path = ".", features = ["test-support"] }
 tokio = { workspace = true, features = ["test-util"] }
 
 [dependencies]
@@ -26,12 +29,14 @@ hypr-host = { workspace = true }
 hypr-notification-interface = { workspace = true }
 
 tauri = { workspace = true, features = ["specta", "test"] }
+tauri-plugin-settings = { workspace = true }
 tauri-plugin-windows = { workspace = true }
 
 specta = { workspace = true }
 tauri-specta = { workspace = true, features = ["derive", "typescript"] }
 
 serde = { workspace = true }
+serde_json = { workspace = true }
 thiserror = { workspace = true }
 uuid = { workspace = true, features = ["v4"] }
 

plugins/detect/Cargo.toml

@@ -4,9 +4,10 @@ use tauri_specta::Event;
 
 use crate::DetectEvent;
 
-pub(crate) trait Env: Clone + Send + Sync + 'static {
+pub trait Env: Clone + Send + Sync + 'static {
     fn emit(&self, event: DetectEvent);
     fn is_do_not_disturb(&self) -> bool;
+    fn is_detect_enabled(&self) -> bool;
 }
 
 pub(crate) struct TauriEnv<R: Runtime> {
@@ -34,31 +35,54 @@ impl<R: Runtime> Env for TauriEnv<R> {
     fn is_do_not_disturb(&self) -> bool {
         crate::dnd::is_do_not_disturb()
     }
+
+    fn is_detect_enabled(&self) -> bool {
+        read_detect_enabled_settings(&self.app_handle).unwrap_or(true)
+    }
+}
+
+fn read_detect_enabled_settings<R: Runtime>(app_handle: &AppHandle<R>) -> Option<bool> {
+    use tauri_plugin_settings::SettingsPluginExt;
+
+    let path = app_handle.settings().settings_path().ok()?;
+    let content = std::fs::read_to_string(path.as_str()).ok()?;
+    let settings: serde_json::Value = serde_json::from_str(&content).ok()?;
+
+    settings
+        .get("notification")
+        .and_then(|n| n.get("detect"))
+        .and_then(|d| d.as_bool())
 }
 
-#[cfg(test)]
-pub(crate) mod test_support {
+#[cfg(any(test, feature = "test-support"))]
+pub mod test_support {
     use super::*;
     use std::sync::Arc;
     use std::sync::atomic::{AtomicBool, Ordering};
 
     #[derive(Clone)]
-    pub(crate) struct TestEnv {
-        pub(crate) events: Arc<std::sync::Mutex<Vec<DetectEvent>>>,
+    pub struct TestEnv {
+        pub events: Arc<std::sync::Mutex<Vec<DetectEvent>>>,
         dnd: Arc<AtomicBool>,
+        detect_enabled: Arc<AtomicBool>,
     }
 
     impl TestEnv {
-        pub(crate) fn new() -> Self {
+        pub fn new() -> Self {
             Self {
                 events: Arc::new(std::sync::Mutex::new(Vec::new())),
                 dnd: Arc::new(AtomicBool::new(false)),
+                detect_enabled: Arc::new(AtomicBool::new(true)),
             }
         }
 
-        pub(crate) fn set_dnd(&self, value: bool) {
+        pub fn set_dnd(&self, value: bool) {
             self.dnd.store(value, Ordering::Relaxed);
         }
+
+        pub fn set_detect_enabled(&self, value: bool) {
+            self.detect_enabled.store(value, Ordering::Relaxed);
+        }
     }
 
     impl Env for TestEnv {
@@ -69,5 +93,9 @@ pub(crate) mod test_support {
         fn is_do_not_disturb(&self) -> bool {
             self.dnd.load(Ordering::Relaxed)
         }
+
+        fn is_detect_enabled(&self) -> bool {
+            self.detect_enabled.load(Ordering::Relaxed)
+        }
     }
 }