voirs_spatial/

mobile.rs

//! Mobile Platform Optimizations for VoiRS Spatial Audio
//!
//! This module provides platform-specific optimizations for iOS and Android devices,
//! including power management, performance tuning, and mobile-specific audio processing.

use crate::config::SpatialConfig;
use crate::core::SpatialProcessor;
use crate::types::Position3D;
use crate::{Error, Result};
use serde::{Deserialize, Serialize};
use std::time::{Duration, Instant};

/// Mobile platform types
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum MobilePlatform {
    /// iOS (iPhone, iPad)
    Ios,
    /// Android devices
    Android,
    /// Generic mobile platform
    Generic,
}

/// Mobile optimization configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MobileConfig {
    /// Target platform
    pub platform: MobilePlatform,
    /// Battery optimization level (0.0 = performance, 1.0 = maximum battery life)
    pub battery_optimization: f32,
    /// Thermal throttling threshold (°C)
    pub thermal_threshold: f32,
    /// Maximum CPU usage percentage
    pub max_cpu_usage: f32,
    /// Adaptive quality enabled
    pub adaptive_quality: bool,
    /// Background processing enabled
    pub background_processing: bool,
    /// Maximum concurrent sources in low power mode
    pub low_power_max_sources: usize,
    /// Reduced sample rate for battery saving
    pub battery_sample_rate: f32,
    /// Use device-specific optimizations
    pub device_optimizations: bool,
    /// Enable spatial audio in calls/media
    pub media_integration: bool,
}

impl Default for MobileConfig {
    fn default() -> Self {
        Self {
            platform: MobilePlatform::Generic,
            battery_optimization: 0.3,
            thermal_threshold: 40.0,
            max_cpu_usage: 25.0,
            adaptive_quality: true,
            background_processing: false,
            low_power_max_sources: 8,
            battery_sample_rate: 24000.0,
            device_optimizations: true,
            media_integration: true,
        }
    }
}

/// Mobile device capabilities and characteristics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MobileDevice {
    /// Device model/name
    pub model: String,
    /// Available CPU cores
    pub cpu_cores: usize,
    /// RAM in MB
    pub ram_mb: u32,
    /// Battery capacity in mAh
    pub battery_capacity: u32,
    /// Supports hardware audio acceleration
    pub has_audio_hardware: bool,
    /// Supports metal/vulkan GPU acceleration
    pub has_gpu_acceleration: bool,
    /// Maximum supported sample rate
    pub max_sample_rate: f32,
    /// Built-in spatial audio support
    pub native_spatial_support: bool,
}

impl Default for MobileDevice {
    fn default() -> Self {
        Self {
            model: "Unknown".to_string(),
            cpu_cores: 4,
            ram_mb: 4096,
            battery_capacity: 3000,
            has_audio_hardware: true,
            has_gpu_acceleration: false,
            max_sample_rate: 48000.0,
            native_spatial_support: false,
        }
    }
}

/// Power management states
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum PowerState {
    /// Full performance mode
    Performance,
    /// Balanced mode
    Balanced,
    /// Power saving mode
    PowerSaver,
    /// Ultra low power mode
    UltraLowPower,
    /// Thermal throttling active
    Throttled,
}

/// Mobile audio quality preset
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum QualityPreset {
    /// Maximum quality (high battery usage)
    Ultra,
    /// High quality
    High,
    /// Balanced quality/performance
    Medium,
    /// Low quality (battery optimized)
    Low,
    /// Minimal quality (emergency battery mode)
    Minimal,
}

impl QualityPreset {
    /// Get quality level as float
    pub fn as_float(&self) -> f32 {
        match self {
            QualityPreset::Ultra => 1.0,
            QualityPreset::High => 0.8,
            QualityPreset::Medium => 0.6,
            QualityPreset::Low => 0.4,
            QualityPreset::Minimal => 0.2,
        }
    }

    /// Get maximum sources for this quality preset
    pub fn max_sources(&self) -> usize {
        match self {
            QualityPreset::Ultra => 32,
            QualityPreset::High => 16,
            QualityPreset::Medium => 12,
            QualityPreset::Low => 8,
            QualityPreset::Minimal => 4,
        }
    }

    /// Get preferred sample rate for this preset
    pub fn sample_rate(&self) -> f32 {
        match self {
            QualityPreset::Ultra => 48000.0,
            QualityPreset::High => 44100.0,
            QualityPreset::Medium => 32000.0,
            QualityPreset::Low => 24000.0,
            QualityPreset::Minimal => 16000.0,
        }
    }
}

/// Mobile optimizer for spatial audio
pub struct MobileOptimizer {
    config: MobileConfig,
    device: MobileDevice,
    current_power_state: PowerState,
    current_quality: QualityPreset,
    battery_level: f32,
    thermal_state: f32,
    cpu_usage_history: Vec<f32>,
    performance_metrics: MobileMetrics,
    last_optimization: Instant,
}

/// Mobile performance metrics
#[derive(Debug, Clone, Default)]
pub struct MobileMetrics {
    /// Average CPU usage percentage
    pub cpu_usage: f32,
    /// Current thermal state (0.0 = cool, 1.0 = hot)
    pub thermal_state: f32,
    /// Battery drain rate (mA/hour)
    pub battery_drain_rate: f32,
    /// Processing latency (ms)
    pub processing_latency: f32,
    /// Quality level achieved
    pub quality_level: f32,
    /// Number of sources processed
    pub sources_processed: u32,
    /// Frame drops per second
    pub frame_drops: f32,
    /// Memory usage (MB)
    pub memory_usage: f32,
}

impl MobileOptimizer {
    /// Create a new mobile optimizer
    pub fn new(config: MobileConfig, device: MobileDevice) -> Self {
        let initial_quality = if config.battery_optimization > 0.7 {
            QualityPreset::Low
        } else if config.battery_optimization > 0.5 {
            QualityPreset::Medium
        } else {
            QualityPreset::High
        };

        Self {
            config,
            device,
            current_power_state: PowerState::Balanced,
            current_quality: initial_quality,
            battery_level: 1.0,
            thermal_state: 0.0,
            cpu_usage_history: Vec::with_capacity(60), // 1 minute of history
            performance_metrics: MobileMetrics::default(),
            last_optimization: Instant::now(),
        }
    }

    /// Update system state and optimize accordingly
    pub fn update_state(&mut self, battery_level: f32, thermal_temp: f32, cpu_usage: f32) {
        self.battery_level = battery_level.clamp(0.0, 1.0);
        self.thermal_state = (thermal_temp - 20.0) / (self.config.thermal_threshold - 20.0);
        self.thermal_state = self.thermal_state.clamp(0.0, 1.0);

        // Update CPU usage history
        self.cpu_usage_history.push(cpu_usage);
        if self.cpu_usage_history.len() > 60 {
            self.cpu_usage_history.remove(0);
        }

        // Update metrics
        self.performance_metrics.cpu_usage = cpu_usage;
        self.performance_metrics.thermal_state = self.thermal_state;

        // Determine power state
        self.current_power_state = self.determine_power_state();

        // Adjust quality based on state
        if self.config.adaptive_quality {
            self.current_quality = self.determine_optimal_quality();
        }
    }

    /// Determine optimal power state based on current conditions
    fn determine_power_state(&self) -> PowerState {
        // Thermal throttling takes priority
        if self.thermal_state > 0.9 {
            return PowerState::Throttled;
        }

        // Ultra low power if battery is critically low
        if self.battery_level < 0.1 {
            return PowerState::UltraLowPower;
        }

        // Power saver if battery is low or high optimization requested
        if self.battery_level < 0.2 || self.config.battery_optimization > 0.7 {
            return PowerState::PowerSaver;
        }

        // Performance mode if battery is high and optimization is low
        if self.battery_level > 0.8 && self.config.battery_optimization < 0.3 {
            return PowerState::Performance;
        }

        // Default to balanced
        PowerState::Balanced
    }

    /// Determine optimal quality preset
    fn determine_optimal_quality(&self) -> QualityPreset {
        let avg_cpu = if self.cpu_usage_history.is_empty() {
            0.0
        } else {
            self.cpu_usage_history.iter().sum::<f32>() / self.cpu_usage_history.len() as f32
        };

        match self.current_power_state {
            PowerState::Performance => {
                if avg_cpu < 20.0 {
                    QualityPreset::Ultra
                } else {
                    QualityPreset::High
                }
            }
            PowerState::Balanced => {
                if avg_cpu < 15.0 {
                    QualityPreset::High
                } else {
                    QualityPreset::Medium
                }
            }
            PowerState::PowerSaver => {
                if avg_cpu < 10.0 {
                    QualityPreset::Medium
                } else {
                    QualityPreset::Low
                }
            }
            PowerState::UltraLowPower | PowerState::Throttled => QualityPreset::Minimal,
        }
    }

    /// Get optimized spatial configuration for current state
    pub fn get_optimized_config(&self) -> SpatialConfig {
        let mut config = SpatialConfig::default();

        // Adjust based on quality preset
        config.quality_level = self.current_quality.as_float();
        config.max_sources = self.current_quality.max_sources();
        config.sample_rate = self.current_quality.sample_rate() as u32;

        // Platform-specific optimizations
        match self.config.platform {
            MobilePlatform::Ios => {
                // iOS-specific optimizations
                config.use_gpu = self.device.has_gpu_acceleration
                    && matches!(
                        self.current_power_state,
                        PowerState::Performance | PowerState::Balanced
                    );
                config.buffer_size = if self.current_power_state == PowerState::UltraLowPower {
                    2048
                } else {
                    1024
                };
            }
            MobilePlatform::Android => {
                // Android-specific optimizations
                config.use_gpu = self.device.has_gpu_acceleration
                    && !matches!(
                        self.current_power_state,
                        PowerState::PowerSaver | PowerState::UltraLowPower
                    );
                config.buffer_size = if self.current_power_state == PowerState::UltraLowPower {
                    4096
                } else {
                    1024
                };
            }
            MobilePlatform::Generic => {
                // Conservative settings for unknown platforms
                config.use_gpu = false;
                config.buffer_size = 2048;
            }
        }

        // Thermal throttling adjustments
        if self.current_power_state == PowerState::Throttled {
            config.quality_level *= 0.5;
            config.max_sources = (config.max_sources / 2).max(2);
            config.use_gpu = false;
        }

        config
    }

    /// Process audio with mobile-optimized settings
    pub fn process_mobile_audio(
        &mut self,
        processor: &mut SpatialProcessor,
        audio_data: &[f32],
        listener_pos: Position3D,
        sources: &[(Position3D, &[f32])],
    ) -> Result<Vec<f32>> {
        let start_time = Instant::now();

        // Limit sources based on current power state
        let max_sources = self.current_quality.max_sources();
        let limited_sources = if sources.len() > max_sources {
            &sources[..max_sources]
        } else {
            sources
        };

        // Process with current settings
        // This would integrate with the actual spatial processor
        let output = vec![0.0f32; audio_data.len()];

        // Update metrics
        let processing_time = start_time.elapsed();
        self.performance_metrics.processing_latency = processing_time.as_secs_f32() * 1000.0;
        self.performance_metrics.sources_processed = limited_sources.len() as u32;
        self.performance_metrics.quality_level = self.current_quality.as_float();

        // Check if we need to drop frames due to performance
        if processing_time > Duration::from_millis(20) {
            // Assuming 50fps target
            self.performance_metrics.frame_drops += 1.0;
        }

        Ok(output)
    }

    /// Get current performance metrics
    pub fn get_metrics(&self) -> MobileMetrics {
        self.performance_metrics.clone()
    }

    /// Get current power state
    pub fn get_power_state(&self) -> PowerState {
        self.current_power_state
    }

    /// Get current quality preset
    pub fn get_quality_preset(&self) -> QualityPreset {
        self.current_quality
    }

    /// Force a specific quality preset
    pub fn set_quality_preset(&mut self, preset: QualityPreset) {
        self.current_quality = preset;
    }

    /// Enable/disable background processing
    pub fn set_background_processing(&mut self, enabled: bool) {
        self.config.background_processing = enabled;
    }

    /// Check if background processing is enabled
    pub fn is_background_processing_enabled(&self) -> bool {
        self.config.background_processing
    }
}

/// iOS-specific optimizations
pub mod ios {
    use super::*;

    /// iOS device detection
    pub fn detect_device() -> MobileDevice {
        MobileDevice {
            model: "iOS Device".to_string(),
            cpu_cores: 6, // Typical for modern iPhones
            ram_mb: 6144, // Common iPhone configuration
            battery_capacity: 3200,
            has_audio_hardware: true, // iOS devices have good audio hardware
            has_gpu_acceleration: true, // Metal support
            max_sample_rate: 48000.0,
            native_spatial_support: true, // iOS has spatial audio support
        }
    }

    /// iOS-specific audio session configuration
    pub fn configure_audio_session() -> Result<()> {
        // Would configure AVAudioSession for spatial audio
        // This would be implemented with iOS-specific APIs
        Ok(())
    }

    /// Enable iOS spatial audio features
    pub fn enable_spatial_audio() -> Result<()> {
        // Would enable spatial audio through AVAudioSession
        Ok(())
    }
}

/// Android-specific optimizations
pub mod android {
    use super::*;

    /// Android device detection
    pub fn detect_device() -> MobileDevice {
        MobileDevice {
            model: "Android Device".to_string(),
            cpu_cores: 8, // Typical for modern Android phones
            ram_mb: 8192, // Common Android configuration
            battery_capacity: 4000,
            has_audio_hardware: true,
            has_gpu_acceleration: true, // Vulkan/OpenGL ES support
            max_sample_rate: 48000.0,
            native_spatial_support: false, // Most Android devices don't have native support
        }
    }

    /// Android-specific audio configuration
    pub fn configure_audio_track() -> Result<()> {
        // Would configure AudioTrack for low-latency audio
        Ok(())
    }

    /// Enable Android spatial audio features (if available)
    pub fn enable_spatial_audio() -> Result<()> {
        // Would enable spatial audio through Android APIs
        Ok(())
    }
}

/// Platform-specific optimizations for iOS devices
#[cfg(target_os = "ios")]
pub mod ios_optimizations {
    use super::*;

    /// iOS-specific audio configuration using AVAudioEngine integration
    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct IosAudioConfig {
        /// Use AVAudioEngine for hardware acceleration
        pub use_av_audio_engine: bool,
        /// Enable spatial audio in iOS native framework
        pub native_spatial_audio: bool,
        /// Use iOS audio interruption handling
        pub handle_audio_interruptions: bool,
        /// Enable AirPods Pro head tracking integration
        pub airpods_head_tracking: bool,
        /// Use iOS Core Audio for low-latency processing
        pub use_core_audio: bool,
        /// Buffer size optimized for iOS (256, 512, 1024 samples)
        pub ios_buffer_size: usize,
    }

    impl Default for IosAudioConfig {
        fn default() -> Self {
            Self {
                use_av_audio_engine: true,
                native_spatial_audio: true,
                handle_audio_interruptions: true,
                airpods_head_tracking: true,
                use_core_audio: true,
                ios_buffer_size: 512,
            }
        }
    }

    /// iOS device capabilities detection
    pub struct IosDeviceDetector;

    impl IosDeviceDetector {
        /// Detect iOS device capabilities
        pub fn detect_device() -> MobileDevice {
            // Platform-specific device detection would be implemented here
            // using iOS system APIs
            MobileDevice {
                model: "iOS Device".to_string(),
                cpu_cores: Self::detect_cpu_cores(),
                ram_mb: Self::detect_ram(),
                battery_capacity: 3000, // Estimated
                has_audio_hardware: true,
                has_gpu_acceleration: Self::has_metal_support(),
                max_sample_rate: 48000.0,
                native_spatial_support: Self::has_spatial_audio_support(),
            }
        }

        fn detect_cpu_cores() -> usize {
            // Would use iOS system APIs to detect actual core count
            std::thread::available_parallelism()
                .map(|n| n.get())
                .unwrap_or(4)
        }

        fn detect_ram() -> u32 {
            // Would use iOS APIs to detect actual RAM
            4096 // Default estimate
        }

        fn has_metal_support() -> bool {
            // Would check for Metal GPU acceleration support
            true // Most modern iOS devices support Metal
        }

        fn has_spatial_audio_support() -> bool {
            // Would check iOS version and device capability
            true // iOS 14+ devices typically support spatial audio
        }
    }

    /// iOS-specific power management
    pub struct IosPowerManager {
        config: IosAudioConfig,
        current_state: PowerState,
    }

    impl IosPowerManager {
        pub fn new(config: IosAudioConfig) -> Self {
            Self {
                config,
                current_state: PowerState::Balanced,
            }
        }

        /// Handle iOS app lifecycle changes
        pub fn handle_app_state_change(&mut self, entering_background: bool) {
            if entering_background {
                self.current_state = PowerState::PowerSaver;
            } else {
                self.current_state = PowerState::Balanced;
            }
        }

        /// Handle iOS audio interruptions (calls, notifications)
        pub fn handle_audio_interruption(&mut self, interrupted: bool) -> Result<()> {
            if self.config.handle_audio_interruptions {
                if interrupted {
                    self.current_state = PowerState::UltraLowPower;
                } else {
                    self.current_state = PowerState::Balanced;
                }
            }
            Ok(())
        }

        /// Get recommended iOS buffer size based on power state
        pub fn get_buffer_size(&self) -> usize {
            match self.current_state {
                PowerState::Performance => 256,
                PowerState::Balanced => 512,
                PowerState::PowerSaver => 1024,
                PowerState::UltraLowPower => 2048,
                PowerState::Throttled => 4096,
            }
        }
    }
}

/// Platform-specific optimizations for Android devices
#[cfg(target_os = "android")]
pub mod android_optimizations {
    use super::*;

    /// Android-specific audio configuration
    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct AndroidAudioConfig {
        /// Use AAudio for low-latency processing
        pub use_aaudio: bool,
        /// Enable OpenSL ES for hardware acceleration
        pub use_opensl_es: bool,
        /// Use Android AudioTrack for output
        pub use_audio_track: bool,
        /// Enable Pro Audio features if available
        pub enable_pro_audio: bool,
        /// Use MMAP for low-latency audio
        pub use_mmap: bool,
        /// Performance class optimization
        pub performance_class: AndroidPerformanceClass,
        /// Target audio latency in milliseconds
        pub target_latency_ms: f32,
    }

    /// Android performance class categories
    #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
    pub enum AndroidPerformanceClass {
        /// High-end devices (R Performance Class or newer)
        Premium,
        /// Mid-range devices with good performance
        Standard,
        /// Basic devices with limited capabilities
        Basic,
        /// Unknown or very old devices
        Legacy,
    }

    impl Default for AndroidAudioConfig {
        fn default() -> Self {
            Self {
                use_aaudio: true,
                use_opensl_es: true,
                use_audio_track: true,
                enable_pro_audio: true,
                use_mmap: true,
                performance_class: AndroidPerformanceClass::Standard,
                target_latency_ms: 20.0,
            }
        }
    }

    /// Android device capabilities detection
    pub struct AndroidDeviceDetector;

    impl AndroidDeviceDetector {
        /// Detect Android device capabilities
        pub fn detect_device() -> MobileDevice {
            MobileDevice {
                model: "Android Device".to_string(),
                cpu_cores: Self::detect_cpu_cores(),
                ram_mb: Self::detect_ram(),
                battery_capacity: Self::detect_battery_capacity(),
                has_audio_hardware: Self::has_audio_hardware(),
                has_gpu_acceleration: Self::has_vulkan_support(),
                max_sample_rate: Self::detect_max_sample_rate(),
                native_spatial_support: Self::has_spatial_audio_support(),
            }
        }

        fn detect_cpu_cores() -> usize {
            std::thread::available_parallelism()
                .map(|n| n.get())
                .unwrap_or(4)
        }

        fn detect_ram() -> u32 {
            // Would use Android APIs to detect actual RAM
            4096 // Default estimate
        }

        fn detect_battery_capacity() -> u32 {
            // Would read from Android battery manager
            3500 // Common Android battery capacity
        }

        fn has_audio_hardware() -> bool {
            // Would check for dedicated audio hardware
            true
        }

        fn has_vulkan_support() -> bool {
            // Would check for Vulkan API support
            false // Conservative default
        }

        fn detect_max_sample_rate() -> f32 {
            // Would query Android AudioManager
            48000.0
        }

        fn has_spatial_audio_support() -> bool {
            // Would check Android version and OEM spatial audio support
            false // Many Android devices don't have native spatial audio
        }

        /// Detect Android performance class
        pub fn detect_performance_class() -> AndroidPerformanceClass {
            // Would use Android APIs to detect performance class
            // Based on Android R Performance Class requirements
            AndroidPerformanceClass::Standard
        }
    }

    /// Android-specific audio optimization
    pub struct AndroidAudioOptimizer {
        config: AndroidAudioConfig,
        performance_class: AndroidPerformanceClass,
    }

    impl AndroidAudioOptimizer {
        pub fn new(config: AndroidAudioConfig) -> Self {
            let performance_class = AndroidDeviceDetector::detect_performance_class();
            Self {
                config,
                performance_class,
            }
        }

        /// Get optimal buffer size for Android device
        pub fn get_optimal_buffer_size(&self) -> usize {
            match self.performance_class {
                AndroidPerformanceClass::Premium => {
                    if self.config.use_mmap {
                        128
                    } else {
                        256
                    }
                }
                AndroidPerformanceClass::Standard => {
                    if self.config.use_aaudio {
                        256
                    } else {
                        512
                    }
                }
                AndroidPerformanceClass::Basic => 1024,
                AndroidPerformanceClass::Legacy => 2048,
            }
        }

        /// Check if low-latency audio is available
        pub fn has_low_latency_audio(&self) -> bool {
            match self.performance_class {
                AndroidPerformanceClass::Premium | AndroidPerformanceClass::Standard => {
                    self.config.use_aaudio || self.config.enable_pro_audio
                }
                _ => false,
            }
        }

        /// Get recommended sample rate
        pub fn get_optimal_sample_rate(&self) -> f32 {
            match self.performance_class {
                AndroidPerformanceClass::Premium => 48000.0,
                AndroidPerformanceClass::Standard => 44100.0,
                AndroidPerformanceClass::Basic => 44100.0,
                AndroidPerformanceClass::Legacy => 22050.0,
            }
        }

        /// Handle Android audio focus changes
        pub fn handle_audio_focus_change(&mut self, has_focus: bool) -> Result<()> {
            // Would integrate with Android AudioFocus system
            if !has_focus {
                // Reduce processing when losing audio focus
            }
            Ok(())
        }
    }
}

/// Cross-platform mobile optimizations
pub struct MobilePlatformOptimizer {
    #[cfg(target_os = "ios")]
    ios_config: ios_optimizations::IosAudioConfig,
    #[cfg(target_os = "android")]
    android_config: android_optimizations::AndroidAudioConfig,
    mobile_config: MobileConfig,
}

impl MobilePlatformOptimizer {
    /// Create new cross-platform mobile optimizer
    pub fn new(mobile_config: MobileConfig) -> Self {
        Self {
            #[cfg(target_os = "ios")]
            ios_config: ios_optimizations::IosAudioConfig::default(),
            #[cfg(target_os = "android")]
            android_config: android_optimizations::AndroidAudioConfig::default(),
            mobile_config,
        }
    }

    /// Get platform-specific optimal buffer size
    pub fn get_platform_buffer_size(&self) -> usize {
        #[cfg(target_os = "ios")]
        {
            let power_manager = ios_optimizations::IosPowerManager::new(self.ios_config.clone());
            power_manager.get_buffer_size()
        }
        #[cfg(target_os = "android")]
        {
            let optimizer =
                android_optimizations::AndroidAudioOptimizer::new(self.android_config.clone());
            optimizer.get_optimal_buffer_size()
        }
        #[cfg(not(any(target_os = "ios", target_os = "android")))]
        {
            1024 // Generic mobile default
        }
    }

    /// Get platform-specific optimal sample rate
    pub fn get_platform_sample_rate(&self) -> f32 {
        #[cfg(target_os = "ios")]
        {
            48000.0 // iOS typically supports high sample rates well
        }
        #[cfg(target_os = "android")]
        {
            let optimizer =
                android_optimizations::AndroidAudioOptimizer::new(self.android_config.clone());
            optimizer.get_optimal_sample_rate()
        }
        #[cfg(not(any(target_os = "ios", target_os = "android")))]
        {
            44100.0 // Generic mobile default
        }
    }

    /// Check if platform has low-latency audio support
    pub fn has_low_latency_support(&self) -> bool {
        #[cfg(target_os = "ios")]
        {
            self.ios_config.use_core_audio || self.ios_config.use_av_audio_engine
        }
        #[cfg(target_os = "android")]
        {
            let optimizer =
                android_optimizations::AndroidAudioOptimizer::new(self.android_config.clone());
            optimizer.has_low_latency_audio()
        }
        #[cfg(not(any(target_os = "ios", target_os = "android")))]
        {
            false
        }
    }
}
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_mobile_config_creation() {
        let config = MobileConfig::default();
        assert_eq!(config.platform, MobilePlatform::Generic);
        assert!(config.adaptive_quality);
    }

    #[test]
    fn test_quality_preset_values() {
        assert_eq!(QualityPreset::Ultra.as_float(), 1.0);
        assert_eq!(QualityPreset::Low.as_float(), 0.4);
        assert_eq!(QualityPreset::Ultra.max_sources(), 32);
        assert_eq!(QualityPreset::Minimal.max_sources(), 4);
    }

    #[test]
    fn test_mobile_optimizer_creation() {
        let config = MobileConfig::default();
        let device = MobileDevice::default();
        let optimizer = MobileOptimizer::new(config, device);

        assert_eq!(optimizer.current_power_state, PowerState::Balanced);
        assert_eq!(optimizer.battery_level, 1.0);
    }

    #[test]
    fn test_power_state_determination() {
        let config = MobileConfig::default();
        let device = MobileDevice::default();
        let mut optimizer = MobileOptimizer::new(config, device);

        // Test low battery
        optimizer.update_state(0.05, 25.0, 10.0);
        assert_eq!(optimizer.get_power_state(), PowerState::UltraLowPower);

        // Test thermal throttling
        optimizer.update_state(0.8, 45.0, 10.0);
        assert_eq!(optimizer.get_power_state(), PowerState::Throttled);

        // Test normal conditions
        optimizer.update_state(0.6, 30.0, 15.0);
        assert_eq!(optimizer.get_power_state(), PowerState::Balanced);
    }

    #[test]
    fn test_quality_adaptation() {
        let config = MobileConfig {
            adaptive_quality: true,
            ..Default::default()
        };
        let device = MobileDevice::default();
        let mut optimizer = MobileOptimizer::new(config, device);

        // High CPU usage should reduce quality
        optimizer.update_state(0.5, 30.0, 35.0);
        let quality = optimizer.get_quality_preset();
        assert!(matches!(
            quality,
            QualityPreset::Low | QualityPreset::Medium
        ));
    }

    #[test]
    fn test_optimized_config_generation() {
        let config = MobileConfig::default();
        let device = MobileDevice::default();
        let optimizer = MobileOptimizer::new(config, device);

        let spatial_config = optimizer.get_optimized_config();
        assert!(spatial_config.quality_level > 0.0);
        assert!(spatial_config.max_sources > 0);
    }

    #[test]
    fn test_ios_device_detection() {
        let device = ios::detect_device();
        assert_eq!(device.model, "iOS Device");
        assert!(device.has_audio_hardware);
        assert!(device.native_spatial_support);
    }

    #[test]
    fn test_android_device_detection() {
        let device = android::detect_device();
        assert_eq!(device.model, "Android Device");
        assert!(device.has_audio_hardware);
        assert!(!device.native_spatial_support);
    }

    #[tokio::test]
    async fn test_mobile_audio_processing() {
        let config = MobileConfig::default();
        let device = MobileDevice::default();
        let mut optimizer = MobileOptimizer::new(config, device);

        // Mock spatial processor (would be real in actual implementation)
        let spatial_config = SpatialConfig::default();
        let mut processor = SpatialProcessor::new(spatial_config).await.unwrap();

        let audio_data = vec![0.5; 1024];
        let listener_pos = Position3D::new(0.0, 0.0, 0.0);
        let sources = vec![
            (Position3D::new(1.0, 0.0, 0.0), audio_data.as_slice()),
            (Position3D::new(-1.0, 0.0, 0.0), audio_data.as_slice()),
        ];

        let result =
            optimizer.process_mobile_audio(&mut processor, &audio_data, listener_pos, &sources);
        assert!(result.is_ok());

        let output = result.unwrap();
        assert_eq!(output.len(), audio_data.len());
    }

    #[test]
    fn test_metrics_collection() {
        let config = MobileConfig::default();
        let device = MobileDevice::default();
        let optimizer = MobileOptimizer::new(config, device);

        let metrics = optimizer.get_metrics();
        assert!(metrics.cpu_usage >= 0.0);
        assert!(metrics.quality_level >= 0.0 && metrics.quality_level <= 1.0);
    }
}