test(sound): check sound files in rust tests

instead of invoking soxi
check that all files are present in the assets
check bits per sample (16 bits)
sounds directory based on cargo manifest path for tests.
tests are run with all other rust 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);
+                        }
                     }
                 });
             }