[*] update normally

Author: heng30

lib/recorder/examples/speaker_recording_demo.rs

@@ -27,7 +27,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         stop_sig_clone.store(true, Ordering::Relaxed);
     });
 
-    let recorder = SpeakerRecorder::new(save_path.clone(), stop_sig, None, false)?;
+    let mut recorder = SpeakerRecorder::new(save_path.clone(), stop_sig, None, false)?;
     recorder.start_recording()?;
     log::info!("Successfully save: {}", save_path.display());
     Ok(())

lib/recorder/src/record_speaker.rs

@@ -120,6 +120,8 @@ pub struct SpeakerRecorder {
     disable_save_file: bool,
     // [0, infinity]
     amplification: Option<Arc<AtomicI32>>,
+
+    device_info: Option<(u32, String)>,
 }
 
 impl SpeakerRecorder {
@@ -165,15 +167,20 @@ impl SpeakerRecorder {
             .connect_rc(None)
             .map_err(|e| SpeakerError::PipewireError(format!("context connect failed: {e}")))?;
 
-        Ok(Self {
+        let mut recoder = Self {
             mainloop,
             core,
             save_path,
             stop_sig,
             level_sender,
             disable_save_file,
             amplification: None,
-        })
+            device_info: None,
+        };
+
+        let output_device = recoder.find_default_output()?;
+        recoder.device_info = output_device.clone();
+        Ok(recoder)
     }
 
     pub fn with_amplification(mut self, v: Arc<AtomicI32>) -> Self {
@@ -204,10 +211,8 @@ impl SpeakerRecorder {
     /// // Start recording (this will block until stop_sig is set)
     /// // recorder.start_recording().unwrap();
     /// ```
-    pub fn start_recording(&self) -> Result<(), SpeakerError> {
-        let output_device = self.find_default_output()?;
-
-        let Some((node_id, node_name)) = output_device else {
+    pub fn start_recording(&mut self) -> Result<(), SpeakerError> {
+        let Some((node_id, ref node_name)) = self.device_info else {
             return Err(SpeakerError::PipewireError(format!(
                 "No found output speaker device (None)"
             )));
@@ -264,6 +269,10 @@ impl SpeakerRecorder {
         Ok(())
     }
 
+    pub fn get_device_info(&self) -> Option<(u32, String)> {
+        self.device_info.clone()
+    }
+
     /// Stop the speaker recording session.
     ///
     /// This method signals the recording thread to stop and clean up resources.
@@ -292,7 +301,7 @@ impl SpeakerRecorder {
         self.stop_sig.store(true, Ordering::Relaxed);
     }
 
-    fn find_default_output(&self) -> Result<Option<(u32, String)>, SpeakerError> {
+    pub fn find_default_output(&self) -> Result<Option<(u32, String)>, SpeakerError> {
         log::info!("Start search output audio devices...");
 
         let registry = self
@@ -318,13 +327,13 @@ impl SpeakerRecorder {
                         (props.get("media.class"), props.get("node.name"))
                     && (media_class == "Audio/Sink" || media_class.starts_with("Audio/Sink"))
                 {
-                    log::debug!(
-                        "Find audio output device : {} (ID: {}), type={:?}, attr: {:?}",
-                        node_name,
-                        global.id,
-                        global.type_,
-                        global.props
-                    );
+                    // log::debug!(
+                    //     "Find audio output device : {} (ID: {}), type={:?}, attr: {:?}",
+                    //     node_name,
+                    //     global.id,
+                    //     global.type_,
+                    //     global.props
+                    // );
 
                     if let Some(priority) = props.get("priority.session")
                         && let Ok(priority) = priority.parse::<i32>()
@@ -347,7 +356,7 @@ impl SpeakerRecorder {
             self.mainloop.loop_().iterate(Duration::from_millis(100));
         }
 
-        log::info!("Use default device: {:?}", output_info);
+        log::info!("Find default device: {:?}", output_info);
 
         let result = output_info
             .lock()

lib/recorder/src/recorder.rs

@@ -466,7 +466,7 @@ impl RecordingSession {
             let recorder = SpeakerRecorder::new(save_path, stop_sig, sender, disable_save_file)
                 .map_err(|e| RecorderError::SpeakerError(e.to_string()))?;
 
-            let recorder = if amplification.is_some() {
+            let mut recorder = if amplification.is_some() {
                 recorder.with_amplification(amplification.unwrap())
             } else {
                 recorder

wayshot/src/logic/recorder.rs

@@ -40,6 +40,8 @@ struct Cache {
 
     recorder_stop_sig: Option<Arc<AtomicBool>>,
     merge_stop_sig: Option<Arc<AtomicBool>>,
+
+    speaker_device_info: Option<(u32, String)>,
 }
 
 static CACHE: Lazy<Mutex<Cache>> = Lazy::new(|| Mutex::new(Cache::default()));
@@ -85,7 +87,7 @@ pub fn init(ui: &AppWindow) {
     logic_cb!(choose_save_dir, ui);
     logic_cb!(input_audio_amplification_changed, ui, v);
     logic_cb!(desktop_speaker_amplification_changed, ui, v);
-    logic_cb!(refresh_desktop_speaker, ui);
+    logic_cb!(refresh_desktop_speaker, ui, show_toast);
     logic_cb!(input_audio_changed, ui, name, show_toast);
     logic_cb!(start_recording, ui);
     logic_cb!(stop_recording, ui);
@@ -104,9 +106,7 @@ fn inner_init(ui: &AppWindow) {
         toast_warn!(ui, format!("{e}"));
     }
 
-    if let Err(e) = init_desktop_speaker(&ui) {
-        toast_warn!(ui, format!("{e}"));
-    }
+    init_desktop_speaker(&ui);
 
     if let Err(e) = init_video(&ui) {
         toast_warn!(ui, format!("{e}"));
@@ -173,7 +173,38 @@ fn init_input_audio(ui: &AppWindow) -> Result<()> {
     Ok(())
 }
 
-fn init_desktop_speaker(ui: &AppWindow) -> Result<()> {
+fn init_desktop_speaker(ui: &AppWindow) {
+    let ui_weak = ui.as_weak();
+
+    if let Err(e) = create_desktop_speaker(ui) {
+        log::warn!("{e}");
+    }
+
+    thread::spawn(move || {
+        let Ok(recorder) =
+            SpeakerRecorder::new(PathBuf::new(), Arc::new(AtomicBool::new(false)), None, true)
+        else {
+            log::warn!("init desktop speaker recorder failed");
+            return;
+        };
+
+        loop {
+            thread::sleep(std::time::Duration::from_secs(5));
+
+            let device_info = CACHE.lock().unwrap().speaker_device_info.clone();
+
+            if speaker_device_changed(&recorder, &device_info) {
+                log::info!("speaker device changed: current speaker deivce info: {device_info:?}");
+
+                _ = ui_weak.clone().upgrade_in_event_loop(move |ui| {
+                    refresh_desktop_speaker(&ui, false);
+                });
+            }
+        }
+    });
+}
+
+fn create_desktop_speaker(ui: &AppWindow) -> Result<()> {
     let ui_weak = ui.as_weak();
 
     thread::spawn(move || {
@@ -212,12 +243,13 @@ fn init_desktop_speaker(ui: &AppWindow) -> Result<()> {
                 let amplification = Arc::new(AtomicI32::new(
                     config::all().control.desktop_speaker_gain as i32,
                 ));
-                let recorder = recorder.with_amplification(amplification.clone());
+                let mut recorder = recorder.with_amplification(amplification.clone());
 
                 {
                     let mut cache = CACHE.lock().unwrap();
                     cache.desktop_speaker_stop_sig = Some(stop_sig);
                     cache.desktop_speaker_amplification = Some(amplification);
+                    cache.speaker_device_info = recorder.get_device_info();
                 }
 
                 if let Err(e) = recorder.start_recording() {
@@ -378,18 +410,37 @@ fn desktop_speaker_amplification_changed(_ui: &AppWindow, v: f32) {
     }
 }
 
-fn refresh_desktop_speaker(ui: &AppWindow) {
+fn refresh_desktop_speaker(ui: &AppWindow, show_toast: bool) {
     {
         if let Some(stop_sig) = CACHE.lock().unwrap().desktop_speaker_stop_sig.take() {
             stop_sig.store(true, Ordering::Relaxed);
         }
     }
 
-    if let Err(e) = init_desktop_speaker(ui) {
-        toast_warn!(ui, format!("{e}"));
+    if let Err(e) = create_desktop_speaker(ui) {
+        if show_toast {
+            toast_warn!(ui, format!("{e}"));
+        } else {
+            log::warn!("{e}");
+        }
     } else {
-        toast_success!(ui, "refresh successfully");
+        if show_toast {
+            toast_success!(ui, "refresh successfully");
+        }
+    }
+}
+
+fn speaker_device_changed(recorder: &SpeakerRecorder, device_info: &Option<(u32, String)>) -> bool {
+    let Ok(Some((node_id, node_name))) = recorder.find_default_output() else {
+        log::warn!("find default speaker device failed");
+        return false;
+    };
+
+    if let Some((old_node_id, old_node_name)) = device_info {
+        return node_id != *old_node_id || node_name.as_str() != old_node_name.as_str();
     }
+
+    true
 }
 
 fn input_audio_changed(ui: &AppWindow, name: SharedString, show_toast: bool) {

wayshot/ui/logic.slint

@@ -80,7 +80,7 @@ export global Logic {
     callback input-audio-changed(name: string, show-toast: bool);
     callback input-audio-amplification-changed(value: float);
     callback desktop-speaker-amplification-changed(value: float);
-    callback refresh-desktop-speaker();
+    callback refresh-desktop-speaker(show-toast: bool);
     callback start-recording();
     callback stop-recording();
     callback stop-merge-tracks();

wayshot/ui/panel/desktop/home.slint

@@ -257,7 +257,7 @@ component ControlPanel inherits HorizontalLayout {
                     colorize: desktop-speaker-slider.enabled ? Theme.icon-color : Theme.disabled-color;
 
                     clicked => {
-                        Logic.refresh-desktop-speaker();
+                        Logic.refresh-desktop-speaker(true);
                     }
                 }
             }