feat: 初步增加 Windows 支持

src/audio/controller.rs

@@ -1,107 +1,21 @@
 //! Device selection, quality presets, streaming.
 
-use serde::{Deserialize, Serialize};
-use std::str::FromStr;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
-use std::time::Duration;
 use tokio::sync::RwLock;
-use tracing::{debug, info, warn};
+use tracing::{debug, info};
 
 use super::capture::AudioConfig;
-use super::device::{
-    enumerate_audio_devices, enumerate_audio_devices_with_current, find_best_audio_device,
-    AudioDeviceInfo,
-};
-use super::encoder::{OpusConfig, OpusFrame};
+use super::device::{enumerate_audio_devices_with_current, find_best_audio_device, AudioDeviceInfo};
+use super::encoder::OpusFrame;
 use super::monitor::AudioHealthMonitor;
-use super::streamer::{AudioStreamState, AudioStreamer, AudioStreamerConfig};
+use super::streamer::{AudioStreamer, AudioStreamerConfig};
+use super::recovery;
+use super::types::{AudioControllerConfig, AudioQuality, AudioStatus};
 use crate::error::{AppError, Result};
-use crate::events::{EventBus, StreamDeviceLostKind, SystemEvent};
+use crate::events::EventBus;
 
-const AUDIO_RECOVERY_RETRY_DELAY: Duration = Duration::from_secs(1);
-
-type AudioRecoveredCallback = Arc<dyn Fn() + Send + Sync>;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
-#[serde(rename_all = "lowercase")]
-pub enum AudioQuality {
-    Voice,
-    #[default]
-    Balanced,
-    High,
-}
-
-impl AudioQuality {
-    pub fn bitrate(&self) -> u32 {
-        match self {
-            AudioQuality::Voice => 32000,
-            AudioQuality::Balanced => 64000,
-            AudioQuality::High => 128000,
-        }
-    }
-
-    pub fn to_opus_config(&self) -> OpusConfig {
-        match self {
-            AudioQuality::Voice => OpusConfig::voice(),
-            AudioQuality::Balanced => OpusConfig::default(),
-            AudioQuality::High => OpusConfig::music(),
-        }
-    }
-}
-
-impl FromStr for AudioQuality {
-    type Err = AppError;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        match s.trim().to_lowercase().as_str() {
-            "voice" => Ok(Self::Voice),
-            "balanced" => Ok(Self::Balanced),
-            "high" => Ok(Self::High),
-            _ => Err(AppError::BadRequest(format!(
-                "invalid audio quality {:?} (expected voice, balanced, or high)",
-                s.trim()
-            ))),
-        }
-    }
-}
-
-impl std::fmt::Display for AudioQuality {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            AudioQuality::Voice => write!(f, "voice"),
-            AudioQuality::Balanced => write!(f, "balanced"),
-            AudioQuality::High => write!(f, "high"),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct AudioControllerConfig {
-    pub enabled: bool,
-    pub device: String,
-    pub quality: AudioQuality,
-}
-
-impl Default for AudioControllerConfig {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            device: String::new(),
-            quality: AudioQuality::Balanced,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct AudioStatus {
-    pub enabled: bool,
-    pub streaming: bool,
-    pub device: Option<String>,
-    pub quality: AudioQuality,
-    pub subscriber_count: usize,
-    pub error: Option<String>,
-}
+pub(super) type AudioRecoveredCallback = Arc<dyn Fn() + Send + Sync>;
 
 pub struct AudioController {
     config: Arc<RwLock<AudioControllerConfig>>,
@@ -135,274 +49,12 @@ impl AudioController {
     }
 
     async fn mark_device_info_dirty(&self) {
-        if let Some(ref bus) = *self.event_bus.read().await {
+        if let Some(bus) = self.event_bus.read().await.as_ref() {
             bus.mark_device_info_dirty();
         }
     }
-
-    async fn publish_state(
-        event_bus: &Arc<RwLock<Option<Arc<EventBus>>>>,
-        state: &str,
-        device: Option<String>,
-        reason: Option<&str>,
-        next_retry_ms: Option<u64>,
-    ) {
-        if let Some(ref bus) = *event_bus.read().await {
-            bus.publish(SystemEvent::StreamStateChanged {
-                state: state.to_string(),
-                device,
-                reason: reason.map(str::to_string),
-                next_retry_ms,
-            });
-            bus.mark_device_info_dirty();
-        }
-    }
-
-    async fn publish_device_lost(
-        event_bus: &Arc<RwLock<Option<Arc<EventBus>>>>,
-        device: &str,
-        reason: &str,
-    ) {
-        if let Some(ref bus) = *event_bus.read().await {
-            bus.publish(SystemEvent::StreamDeviceLost {
-                kind: StreamDeviceLostKind::Audio,
-                device: device.to_string(),
-                reason: reason.to_string(),
-            });
-        }
-    }
-
-    async fn publish_reconnecting(
-        event_bus: &Arc<RwLock<Option<Arc<EventBus>>>>,
-        device: &str,
-        attempt: u32,
-    ) {
-        if let Some(ref bus) = *event_bus.read().await {
-            bus.publish(SystemEvent::StreamReconnecting {
-                device: device.to_string(),
-                attempt,
-            });
-        }
-    }
-
-    async fn publish_recovered(event_bus: &Arc<RwLock<Option<Arc<EventBus>>>>, device: &str) {
-        if let Some(ref bus) = *event_bus.read().await {
-            bus.publish(SystemEvent::StreamRecovered {
-                device: device.to_string(),
-            });
-        }
-    }
-
-    fn select_recovery_device(
-        devices: &[AudioDeviceInfo],
-        preferred: &str,
-    ) -> Option<AudioDeviceInfo> {
-        if !preferred.trim().is_empty() {
-            if let Some(device) = devices.iter().find(|d| d.name == preferred) {
-                return Some(device.clone());
-            }
-        }
-
-        devices
-            .iter()
-            .find(|d| d.is_hdmi && d.sample_rates.contains(&48_000) && d.channels.contains(&2))
-            .or_else(|| {
-                devices
-                    .iter()
-                    .find(|d| d.sample_rates.contains(&48_000) && d.channels.contains(&2))
-            })
-            .or_else(|| devices.first())
-            .cloned()
-    }
-
-    fn spawn_stream_monitor_from_parts(
-        config: Arc<RwLock<AudioControllerConfig>>,
-        streamer_slot: Arc<RwLock<Option<Arc<AudioStreamer>>>>,
-        event_bus: Arc<RwLock<Option<Arc<EventBus>>>>,
-        monitor: Arc<AudioHealthMonitor>,
-        recovery_in_progress: Arc<AtomicBool>,
-        recovered_callback: Arc<RwLock<Option<AudioRecoveredCallback>>>,
-        streamer: Arc<AudioStreamer>,
-        device: String,
-    ) {
-        let mut state_rx = streamer.state_watch();
-
-        tokio::spawn(async move {
-            loop {
-                if state_rx.changed().await.is_err() {
-                    return;
-                }
-
-                if *state_rx.borrow() != AudioStreamState::Error {
-                    continue;
-                }
-
-                {
-                    let current = streamer_slot.read().await;
-                    if !current
-                        .as_ref()
-                        .is_some_and(|current| Arc::ptr_eq(current, &streamer))
-                    {
-                        return;
-                    }
-                }
-
-                let reason = format!("Audio device lost: {}", device);
-                monitor.report_error(&reason, "device_lost").await;
-                Self::spawn_recovery_task_from_parts(
-                    config,
-                    streamer_slot,
-                    event_bus,
-                    monitor,
-                    recovery_in_progress,
-                    recovered_callback,
-                    device,
-                    reason,
-                );
-                return;
-            }
-        });
-    }
-
-    fn spawn_recovery_task_from_parts(
-        config: Arc<RwLock<AudioControllerConfig>>,
-        streamer_slot: Arc<RwLock<Option<Arc<AudioStreamer>>>>,
-        event_bus: Arc<RwLock<Option<Arc<EventBus>>>>,
-        monitor: Arc<AudioHealthMonitor>,
-        recovery_in_progress: Arc<AtomicBool>,
-        recovered_callback: Arc<RwLock<Option<AudioRecoveredCallback>>>,
-        lost_device: String,
-        reason: String,
-    ) {
-        if recovery_in_progress.swap(true, Ordering::SeqCst) {
-            debug!("Audio recovery already in progress");
-            return;
-        }
-
-        tokio::spawn(async move {
-            warn!("Audio recovery started for {}: {}", lost_device, reason);
-            Self::publish_device_lost(&event_bus, &lost_device, &reason).await;
-            Self::publish_state(
-                &event_bus,
-                "device_lost",
-                Some(lost_device.clone()),
-                Some("audio_device_lost"),
-                Some(AUDIO_RECOVERY_RETRY_DELAY.as_millis() as u64),
-            )
-            .await;
-
-            let mut attempt = 0u32;
-
-            loop {
-                if !recovery_in_progress.load(Ordering::SeqCst) {
-                    debug!("Audio recovery canceled");
-                    return;
-                }
-
-                if streamer_slot
-                    .read()
-                    .await
-                    .as_ref()
-                    .is_some_and(|s| s.is_running())
-                {
-                    recovery_in_progress.store(false, Ordering::SeqCst);
-                    return;
-                }
-
-                let cfg = config.read().await.clone();
-                if !cfg.enabled {
-                    recovery_in_progress.store(false, Ordering::SeqCst);
-                    return;
-                }
-
-                attempt = attempt.saturating_add(1);
-                Self::publish_reconnecting(&event_bus, &lost_device, attempt).await;
-                Self::publish_state(
-                    &event_bus,
-                    "device_lost",
-                    Some(lost_device.clone()),
-                    Some("audio_reconnecting"),
-                    Some(AUDIO_RECOVERY_RETRY_DELAY.as_millis() as u64),
-                )
-                .await;
-
-                tokio::time::sleep(AUDIO_RECOVERY_RETRY_DELAY).await;
-
-                let devices = match enumerate_audio_devices() {
-                    Ok(devices) => devices,
-                    Err(e) => {
-                        debug!(
-                            "Audio recovery enumerate failed (attempt {}): {}",
-                            attempt, e
-                        );
-                        continue;
-                    }
-                };
-
-                let Some(device) = Self::select_recovery_device(&devices, &cfg.device) else {
-                    debug!("No audio devices found during recovery attempt {}", attempt);
-                    continue;
-                };
-
-                let streamer_config = AudioStreamerConfig {
-                    capture: AudioConfig {
-                        device_name: device.name.clone(),
-                        ..Default::default()
-                    },
-                    opus: cfg.quality.to_opus_config(),
-                };
-                let new_streamer = Arc::new(AudioStreamer::with_config(streamer_config));
-
-                match new_streamer.start().await {
-                    Ok(()) => {
-                        {
-                            let mut cfg = config.write().await;
-                            cfg.device = device.name.clone();
-                        }
-                        *streamer_slot.write().await = Some(new_streamer.clone());
-                        monitor.report_recovered().await;
-                        Self::publish_recovered(&event_bus, &device.name).await;
-                        if let Some(callback) = recovered_callback.read().await.clone() {
-                            callback();
-                        }
-                        Self::publish_state(
-                            &event_bus,
-                            "streaming",
-                            Some(device.name.clone()),
-                            None,
-                            None,
-                        )
-                        .await;
-                        recovery_in_progress.store(false, Ordering::SeqCst);
-                        info!(
-                            "Audio device recovered with {} after {} attempts",
-                            device.name, attempt
-                        );
-                        Self::spawn_stream_monitor_from_parts(
-                            config,
-                            streamer_slot,
-                            event_bus,
-                            monitor,
-                            recovery_in_progress,
-                            recovered_callback,
-                            new_streamer,
-                            device.name,
-                        );
-                        return;
-                    }
-                    Err(e) => {
-                        debug!(
-                            "Audio recovery start failed with {} (attempt {}): {}",
-                            device.name, attempt, e
-                        );
-                    }
-                }
-            }
-        });
-    }
-
     fn spawn_recovery_task(&self, lost_device: String, reason: String) {
-        Self::spawn_recovery_task_from_parts(
+        recovery::spawn_recovery_task(
             self.config.clone(),
             self.streamer.clone(),
             self.event_bus.clone(),
@@ -415,7 +67,7 @@ impl AudioController {
     }
 
     fn spawn_stream_monitor(&self, streamer: Arc<AudioStreamer>, device: String) {
-        Self::spawn_stream_monitor_from_parts(
+        recovery::spawn_stream_monitor(
             self.config.clone(),
             self.streamer.clone(),
             self.event_bus.clone(),
@@ -477,7 +129,7 @@ impl AudioController {
             config.quality = quality;
         }
 
-        if let Some(ref streamer) = *self.streamer.read().await {
+        if let Some(streamer) = self.streamer.read().await.as_ref() {
             streamer.set_bitrate(quality.bitrate()).await?;
         }
 
@@ -578,11 +230,11 @@ impl AudioController {
     }
 
     pub async fn is_streaming(&self) -> bool {
-        if let Some(ref streamer) = *self.streamer.read().await {
-            streamer.is_running()
-        } else {
-            false
-        }
+        self.streamer
+            .read()
+            .await
+            .as_ref()
+            .is_some_and(|streamer| streamer.is_running())
     }
 
     pub async fn status(&self) -> AudioStatus {