sfx fixes

Author: yujonglee

Cargo.lock

@@ -43,6 +43,9 @@ function Component() {
 
   useEffect(() => {
     sfxCommands.play("BGM").catch(console.error);
+    return () => {
+      sfxCommands.stop("BGM").catch(console.error);
+    };
   }, []);
 
   useEffect(() => {

apps/desktop/src/routes/app/onboarding/index.tsx

@@ -24,4 +24,3 @@ specta = { workspace = true }
 strum = { workspace = true, features = ["derive"] }
 
 once_cell = { workspace = true }
-tracing = { workspace = true }

plugins/sfx/Cargo.toml

@@ -3,24 +3,17 @@ use crate::{AppSounds, SfxPluginExt};
 #[tauri::command]
 #[specta::specta]
 pub async fn play<R: tauri::Runtime>(app: tauri::AppHandle<R>, sfx: AppSounds) {
-    tracing::info!("sfx command: play called with {:?}", sfx);
     app.sfx().play(sfx)
 }
 
 #[tauri::command]
 #[specta::specta]
 pub async fn stop<R: tauri::Runtime>(app: tauri::AppHandle<R>, sfx: AppSounds) {
-    tracing::info!("sfx command: stop called with {:?}", sfx);
     app.sfx().stop(sfx)
 }
 
 #[tauri::command]
 #[specta::specta]
 pub async fn set_volume<R: tauri::Runtime>(app: tauri::AppHandle<R>, sfx: AppSounds, volume: f32) {
-    tracing::info!(
-        "sfx command: set_volume called with {:?}, volume: {}",
-        sfx,
-        volume
-    );
     app.sfx().set_volume(sfx, volume)
 }

plugins/sfx/src/commands.rs

@@ -20,85 +20,54 @@ pub enum AppSounds {
     BGM,
 }
 
-pub fn to_speaker(bytes: &'static [u8], looping: bool) -> std::sync::mpsc::Sender<SoundControl> {
+pub(crate) fn to_speaker(
+    bytes: &'static [u8],
+    looping: bool,
+) -> std::sync::mpsc::Sender<SoundControl> {
     use rodio::source::Source;
     use rodio::{Decoder, OutputStream, Sink};
     let (tx, rx) = std::sync::mpsc::channel();
 
     std::thread::spawn(move || {
-        eprintln!(
-            "[sfx] attempting to play audio, bytes len: {}, looping: {}",
-            bytes.len(),
-            looping
-        );
-        tracing::info!(
-            "sfx: attempting to play audio, bytes len: {}, looping: {}",
-            bytes.len(),
-            looping
-        );
-
-        match OutputStream::try_default() {
-            Ok((stream, stream_handle)) => {
-                eprintln!("[sfx] got output stream");
-                tracing::info!("sfx: got output stream");
-                let file = std::io::Cursor::new(bytes);
-
-                match Decoder::new(file) {
-                    Ok(source) => {
-                        eprintln!("[sfx] decoded audio source successfully");
-                        tracing::info!("sfx: decoded audio source");
-
-                        match Sink::try_new(&stream_handle) {
-                            Ok(sink) => {
-                                eprintln!("[sfx] created sink, appending source and playing");
-                                tracing::info!("sfx: created sink, appending source");
-
-                                if looping {
-                                    sink.append(source.repeat_infinite());
-                                } else {
-                                    sink.append(source);
-                                }
-
-                                loop {
-                                    match rx.recv_timeout(std::time::Duration::from_millis(100)) {
-                                        Ok(SoundControl::Stop) => {
-                                            eprintln!("[sfx] stopping playback");
-                                            sink.stop();
-                                            break;
-                                        }
-                                        Ok(SoundControl::SetVolume(volume)) => {
-                                            eprintln!("[sfx] setting volume to {}", volume);
-                                            sink.set_volume(volume);
-                                        }
-                                        Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
-                                            if !looping && sink.empty() {
-                                                break;
-                                            }
-                                        }
-                                        Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
-                                            break;
-                                        }
-                                    }
-                                }
-                                drop(stream);
-                            }
-                            Err(e) => {
-                                eprintln!("[sfx] ERROR: failed to create sink: {:?}", e);
-                                tracing::error!("sfx: failed to create sink: {:?}", e);
-                            }
-                        }
-                    }
-                    Err(e) => {
-                        eprintln!("[sfx] ERROR: failed to decode audio: {:?}", e);
-                        tracing::error!("sfx: failed to decode audio: {:?}", e);
+        let Ok((stream, stream_handle)) = OutputStream::try_default() else {
+            return;
+        };
+
+        let file = std::io::Cursor::new(bytes);
+        let Ok(source) = Decoder::new(file) else {
+            return;
+        };
+
+        let Ok(sink) = Sink::try_new(&stream_handle) else {
+            return;
+        };
+
+        if looping {
+            sink.append(source.repeat_infinite());
+        } else {
+            sink.append(source);
+        }
+
+        loop {
+            match rx.recv_timeout(std::time::Duration::from_millis(100)) {
+                Ok(SoundControl::Stop) => {
+                    sink.stop();
+                    break;
+                }
+                Ok(SoundControl::SetVolume(volume)) => {
+                    sink.set_volume(volume);
+                }
+                Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
+                    if !looping && sink.empty() {
+                        break;
                     }
                 }
-            }
-            Err(e) => {
-                eprintln!("[sfx] ERROR: failed to get output stream: {:?}", e);
-                tracing::error!("sfx: failed to get output stream: {:?}", e);
+                Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
+                    break;
+                }
             }
         }
+        drop(stream);
     });
 
     tx