refactor(aaudio): simplify Stream from enum to struct

Replace `Stream` enum with a struct containing `inner: Arc<Mutex<AudioStream>>`
and `direction: DeviceDirection` fields. This eliminates code duplication while
maintaining the same functionality.

Author: roderickvd

src/host/aaudio/mod.rs

@@ -131,9 +131,9 @@ pub struct Device(Option<AudioDeviceInfo>);
 /// - The pointer in AudioStream (NonNull<AAudioStreamStruct>) is valid for the lifetime
 ///   of the stream and AAudio C API functions are thread-safe at the C level
 #[derive(Clone)]
-pub enum Stream {
-    Input(Arc<Mutex<AudioStream>>),
-    Output(Arc<Mutex<AudioStream>>),
+pub struct Stream {
+    inner: Arc<Mutex<AudioStream>>,
+    direction: DeviceDirection,
 }
 
 // SAFETY: AudioStream can be safely sent between threads. The AAudio C API is thread-safe
@@ -281,7 +281,7 @@ fn configure_for_device(
         BufferSize::Default => {
             // Use the optimal burst size from AudioManager:
             // https://developer.android.com/ndk/guides/audio/audio-latency#buffer-size
-            AudioManager::get_frames_per_buffer().ok()
+            AudioManager::get_frames_per_buffer().ok().map(|s| s as u32)
         }
         BufferSize::Fixed(size) => Some(size),
     };
@@ -339,7 +339,10 @@ where
     // is safe because the Mutex provides exclusive access and AudioStream's thread safety
     // is documented in the AAudio C API.
     #[allow(clippy::arc_with_non_send_sync)]
-    Ok(Stream::Input(Arc::new(Mutex::new(stream))))
+    Ok(Stream {
+        inner: Arc::new(Mutex::new(stream)),
+        direction: DeviceDirection::Input,
+    })
 }
 
 fn build_output_stream<D, E>(
@@ -385,7 +388,10 @@ where
     // is safe because the Mutex provides exclusive access and AudioStream's thread safety
     // is documented in the AAudio C API.
     #[allow(clippy::arc_with_non_send_sync)]
-    Ok(Stream::Output(Arc::new(Mutex::new(stream))))
+    Ok(Stream {
+        inner: Arc::new(Mutex::new(stream)),
+        direction: DeviceDirection::Output,
+    })
 }
 
 impl DeviceTrait for Device {
@@ -588,47 +594,40 @@ impl DeviceTrait for Device {
 
 impl StreamTrait for Stream {
     fn play(&self) -> Result<(), PlayStreamError> {
-        match self {
-            Self::Input(stream) => stream
-                .lock()
-                .unwrap()
-                .request_start()
-                .map_err(PlayStreamError::from),
-            Self::Output(stream) => stream
-                .lock()
-                .unwrap()
-                .request_start()
-                .map_err(PlayStreamError::from),
-        }
+        self.inner
+            .lock()
+            .unwrap()
+            .request_start()
+            .map_err(PlayStreamError::from)
     }
 
     fn pause(&self) -> Result<(), PauseStreamError> {
-        match self {
-            Self::Input(_) => Err(BackendSpecificError {
+        match self.direction {
+            DeviceDirection::Input => Err(BackendSpecificError {
                 description: "Pause called on the input stream.".to_owned(),
             }
             .into()),
-            Self::Output(stream) => stream
+            DeviceDirection::Output => self
+                .inner
                 .lock()
                 .unwrap()
                 .request_pause()
                 .map_err(PauseStreamError::from),
+            DeviceDirection::Duplex => Err(BackendSpecificError {
+                description: "Duplex streams not supported in AAudio.".to_owned(),
+            }
+            .into()),
         }
     }
 
     fn buffer_size(&self) -> Option<crate::FrameCount> {
-        let stream = match self {
-            Self::Input(stream) => stream.lock().ok()?,
-            Self::Output(stream) => stream.lock().ok()?,
-        };
+        let stream = self.inner.lock().ok()?;
 
         // If frames_per_data_callback was not explicitly set (returning 0),
         // fall back to the burst size as that's what AAudio uses by default.
-        match stream.get_frames_per_data_callback() {
+        match stream.frames_per_data_callback() {
             Some(size) if size > 0 => Some(size as crate::FrameCount),
-            _ => stream
-                .get_frames_per_burst()
-                .map(|f| f as crate::FrameCount),
+            _ => stream.frames_per_burst().map(|f| f as crate::FrameCount),
         }
     }
 }