refactor: remove unused ALSA code and incorrect Send/Sync implementations

Author: roderickvd

src/host/alsa/enumerate.rs

@@ -3,9 +3,7 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use super::{
-    alsa, {Device, DeviceHandles},
-};
+use super::{alsa, Device};
 use crate::{BackendSpecificError, DevicesError};
 
 /// ALSA's implementation for `Devices`.
@@ -26,16 +24,13 @@ impl Devices {
     }
 }
 
-unsafe impl Send for Devices {}
-unsafe impl Sync for Devices {}
-
 impl Iterator for Devices {
     type Item = Device;
 
-    fn next(&mut self) -> Option<Device> {
+    fn next(&mut self) -> Option<Self::Item> {
         loop {
             let hint = self.hint_iter.next()?;
-            if let Ok(device) = Device::try_from(hint) {
+            if let Ok(device) = Self::Item::try_from(hint) {
                 if self.enumerated_pcm_ids.insert(device.pcm_id.clone()) {
                     return Some(device);
                 } else {
@@ -77,20 +72,15 @@ impl TryFrom<alsa::device_name::Hint> for Device {
     type Error = BackendSpecificError;
 
     fn try_from(hint: alsa::device_name::Hint) -> Result<Self, Self::Error> {
-        let pcm_id = hint.name.ok_or_else(|| BackendSpecificError {
+        let pcm_id = hint.name.ok_or_else(|| Self::Error {
             description: "ALSA hint missing PCM ID".to_string(),
         })?;
 
-        // Don't try to open handles during enumeration to avoid ALSA logging errors
-        // for device templates (e.g., with $CARD placeholders) or unavailable devices.
-        // Opening will be attempted when the device is actually used.
-        let handles = DeviceHandles::default();
-
         // Include all devices from ALSA hints (matches `aplay -L` behavior)
         Ok(Self {
             pcm_id: pcm_id.to_owned(),
             desc: hint.desc,
-            handles: Arc::new(Mutex::new(handles)),
+            handles: Arc::new(Mutex::new(Default::default())),
         })
     }
 }

src/host/alsa/mod.rs

@@ -151,7 +151,7 @@ impl DeviceTrait for Device {
     {
         let stream_inner =
             self.build_stream_inner(conf, sample_format, alsa::Direction::Capture)?;
-        let stream = Stream::new_input(
+        let stream = Self::Stream::new_input(
             Arc::new(stream_inner),
             data_callback,
             error_callback,
@@ -174,7 +174,7 @@ impl DeviceTrait for Device {
     {
         let stream_inner =
             self.build_stream_inner(conf, sample_format, alsa::Direction::Playback)?;
-        let stream = Stream::new_output(
+        let stream = Self::Stream::new_output(
             Arc::new(stream_inner),
             data_callback,
             error_callback,
@@ -235,19 +235,6 @@ struct DeviceHandles {
 }
 
 impl DeviceHandles {
-    /// Create `DeviceHandles` for `name` and try to open a handle for both
-    /// directions. Returns `Ok` if either direction is opened successfully.
-    fn open(pcm_id: &str) -> Result<Self, alsa::Error> {
-        let mut handles = Self::default();
-        let playback_err = handles.try_open(pcm_id, alsa::Direction::Playback).err();
-        let capture_err = handles.try_open(pcm_id, alsa::Direction::Capture).err();
-        if let Some(err) = capture_err.and(playback_err) {
-            Err(err)
-        } else {
-            Ok(handles)
-        }
-    }
-
     /// Get a mutable reference to the `Option` for a specific `stream_type`.
     /// If the `Option` is `None`, the `alsa::PCM` will be opened and placed in
     /// the `Option` before returning. If `handle_mut()` returns `Ok` the contained
@@ -1089,7 +1076,7 @@ impl Stream {
                 );
             })
             .unwrap();
-        Stream {
+        Self {
             thread: Some(thread),
             inner,
             trigger: tx,
@@ -1121,7 +1108,7 @@ impl Stream {
                 );
             })
             .unwrap();
-        Stream {
+        Self {
             thread: Some(thread),
             inner,
             trigger: tx,
@@ -1378,7 +1365,7 @@ fn set_sw_params_from_format(
 
 impl From<alsa::Error> for BackendSpecificError {
     fn from(err: alsa::Error) -> Self {
-        BackendSpecificError {
+        Self {
             description: err.to_string(),
         }
     }