test(sound): check sound files in rust tests (#282)

- instead of invoking soxi with bash script.
- check that all files are present in the assets
- check bits per sample (16 bits)
- sounds directory based on cargo manifest path for tests

.github/workflows/rust-ci.yaml

@@ -115,6 +115,7 @@ jobs:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # pin@v3
         with:
           token: ${{ secrets.GIT_HUB_TOKEN }}
+          lfs: true
       - uses: cachix/install-nix-action@ba0dd844c9180cbf77aa72a116d6fbc515d0e87b # pin@v27
         with:
           github_access_token: ${{ secrets.GIT_HUB_TOKEN }}

ui/Cargo.toml

@@ -44,6 +44,7 @@ path = "examples/ui-replay.rs"
 # dependencies for the dbus-client example
 [dev-dependencies]
 chrono = "0.4.35"
+hound = "3.5.1"
 
 [package.metadata.deb]
 maintainer-scripts = "debian/"

ui/sound/examples/queue.rs

@@ -16,9 +16,8 @@ impl AsRef<[u8]> for Sound {
 async fn main() -> Result<()> {
     let queue = Queue::spawn("default")?;
 
-    let connected = Sound(Arc::new(fs::read("sound/examples/voice_connected.wav")?));
-    let overheating =
-        Sound(Arc::new(fs::read("sound/examples/voice_overheating.wav")?));
+    let connected = Sound(Arc::new(fs::read("sound/assets/voice_connected.wav")?));
+    let timeout = Sound(Arc::new(fs::read("sound/assets/voice_timeout.wav")?));
 
     // Said firstly because the queue starts playing immediately.
     queue
@@ -40,19 +39,13 @@ async fn main() -> Result<()> {
     // Said secondly because it has a higher priority than all pending sounds in
     // the queue.
     queue
-        .sound(
-            Some(Cursor::new(overheating.clone())),
-            "overheating".to_string(),
-        )
+        .sound(Some(Cursor::new(timeout.clone())), "timeout".to_string())
         .priority(1)
         .push()?;
     // Not said because it doesn't meet the `max_delay`.
     assert!(
         !queue
-            .sound(
-                Some(Cursor::new(overheating.clone())),
-                "overheating".to_string()
-            )
+            .sound(Some(Cursor::new(timeout.clone())), "timeout".to_string())
             .priority(1)
             .max_delay(Duration::from_secs(1))
             .push()?
@@ -72,7 +65,7 @@ async fn main() -> Result<()> {
     );
 
     // In result the queue should be played in the following order: connected,
-    // overheating, connected, connected.
+    // timeout, connected, connected.
 
     Ok(())
 }

ui/sound/examples/wav.rs

@@ -6,7 +6,7 @@ fn main() -> Result<()> {
     let mut device = Device::open("default")?;
     let mut hw_params = HwParams::new()?;
 
-    let mut wav = File::open("sound/examples/voice_connected.wav")?;
+    let mut wav = File::open("sound/assets/voice_connected.wav")?;
     device.play_wav(&mut wav, &mut hw_params, 1.0)?;
     device.drain()?;
 

ui/src/engine/diamond.rs

@@ -135,10 +135,7 @@ pub async fn event_loop(
             Runner::<DIAMOND_RING_LED_COUNT, DIAMOND_CENTER_LED_COUNT>::new(sound)
         }
         Err(e) => {
-            return {
-                tracing::error!("Failed to initialize sound: {:?}", e);
-                Err(e)
-            };
+            return Err(eyre::eyre!("Failed to initialize sound: {:?}", e));
         }
     };
     loop {
@@ -935,9 +932,17 @@ impl EventHandler for Runner<DIAMOND_RING_LED_COUNT, DIAMOND_CENTER_LED_COUNT> {
                 let sound = self.sound.clone();
                 // spawn a new task because we need some async work here
                 tokio::task::spawn(async move {
-                    let language: Option<&str> = language.as_deref();
-                    if let Err(e) = sound.load_sound_files(language, true).await {
-                        tracing::error!("Error loading sound files: {:?}", e);
+                    match sound::SoundConfig::default()
+                        .with_language(language.as_deref())
+                    {
+                        Ok(config) => {
+                            if let Err(e) = sound.load_sound_files(config).await {
+                                tracing::error!("Error loading sound files: {:?}", e);
+                            }
+                        }
+                        Err(e) => {
+                            tracing::error!("Error creating sound config: {:?}", e);
+                        }
                     }
                 });
             }

ui/src/engine/pearl/mod.rs

@@ -109,10 +109,9 @@ pub async fn event_loop(
     interval.set_missed_tick_behavior(time::MissedTickBehavior::Delay);
     let mut interval = IntervalStream::new(interval);
     let mut rx = UnboundedReceiverStream::new(rx);
-    let mut runner = if let Ok(sound) = sound::Jetson::spawn().await {
-        Runner::<PEARL_RING_LED_COUNT, PEARL_CENTER_LED_COUNT>::new(sound)
-    } else {
-        return Err(eyre::eyre!("Failed to initialize sound"));
+    let mut runner = match sound::Jetson::spawn().await {
+        Ok(sound) => Runner::<PEARL_RING_LED_COUNT, PEARL_CENTER_LED_COUNT>::new(sound),
+        Err(e) => return Err(eyre::eyre!("Failed to initialize sound: {:?}", e)),
     };
     loop {
         match future::select(rx.next(), interval.next()).await {
@@ -274,9 +273,17 @@ impl EventHandler for Runner<PEARL_RING_LED_COUNT, PEARL_CENTER_LED_COUNT> {
                 let sound = self.sound.clone();
                 // spawn a new task because we need some async work here
                 tokio::task::spawn(async move {
-                    let language: Option<&str> = language.as_deref();
-                    if let Err(e) = sound.load_sound_files(language, true).await {
-                        tracing::error!("Error loading sound files: {:?}", e);
+                    match sound::SoundConfig::default()
+                        .with_language(language.as_deref())
+                    {
+                        Ok(config) => {
+                            if let Err(e) = sound.load_sound_files(config).await {
+                                tracing::error!("Error loading sound files: {:?}", e);
+                            }
+                        }
+                        Err(e) => {
+                            tracing::error!("Error creating sound config: {:?}", e);
+                        }
                     }
                 });
             }