use serde::{Deserialize, Serialize}; use std::fs; use std::path::PathBuf; /// Relay/discovery posture, trading connectivity against how much the n0 /// infrastructure learns about you. See the network module for details. #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)] pub enum NetworkMode { /// n0 relay for NAT traversal, but no DNS presence beacon. Peer addresses /// come from the join ticket and gossip, so n0 only sees relayed-call /// metadata, never a standing "I'm online" record. Default. #[default] RelayNoDiscovery, /// Full n0 defaults: relay plus DNS publish/resolve (most convenient, /// most phone-home). N0Full, /// No relay, no discovery: direct hole-punching only. Fully serverless, /// but fails behind symmetric/CGNAT NATs with no fallback. DirectOnly, } impl NetworkMode { /// All variants, for presentation in a picker. pub const ALL: [NetworkMode; 3] = [NetworkMode::RelayNoDiscovery, NetworkMode::N0Full, NetworkMode::DirectOnly]; } impl std::fmt::Display for NetworkMode { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { let label = match self { NetworkMode::RelayNoDiscovery => "Relay, no presence beacon", NetworkMode::N0Full => "n0 defaults (relay + DNS)", NetworkMode::DirectOnly => "Direct only (no relay)", }; f.write_str(label) } } fn default_true() -> bool { true } #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] pub struct AppConfig { pub input_device: String, pub output_device: String, pub noise_gate_threshold: f32, #[serde(default)] pub network_mode: NetworkMode, /// Route audio through PipeWire's echo-cancel module (AEC + noise suppression). /// Takes effect on the next room join. Off by default. #[serde(default)] pub echo_cancellation_enabled: bool, #[serde(default = "default_true")] pub notifications_enabled: bool, #[serde(default)] pub custom_sound_self_join: Option, #[serde(default)] pub custom_sound_peer_join: Option, #[serde(default)] pub custom_sound_peer_leave: Option, #[serde(default)] pub custom_sound_reconnect_attempt: Option, #[serde(default)] pub custom_sound_reconnected: Option, #[serde(default)] pub custom_sound_self_leave: Option, #[serde(default)] pub custom_sound_mic_toggle: Option, #[serde(default)] pub custom_sound_reconnect_failed: Option, } impl Default for AppConfig { fn default() -> Self { Self { input_device: "".to_string(), output_device: "".to_string(), noise_gate_threshold: 0.01, network_mode: NetworkMode::default(), echo_cancellation_enabled: false, notifications_enabled: true, custom_sound_self_join: None, custom_sound_peer_join: None, custom_sound_peer_leave: None, custom_sound_reconnect_attempt: None, custom_sound_reconnected: None, custom_sound_self_leave: None, custom_sound_mic_toggle: None, custom_sound_reconnect_failed: None, } } } impl AppConfig { fn config_path() -> Option { dirs::config_dir().map(|mut p| { p.push("peerspeak"); p.push("config.json"); p }) } pub fn load() -> Self { if let Some(path) = Self::config_path() && let Ok(contents) = fs::read_to_string(&path) && let Ok(config) = serde_json::from_str(&contents) { return config; } Self::default() } pub fn save(&self) { if let Some(path) = Self::config_path() { if let Some(dir) = path.parent() { let _ = fs::create_dir_all(dir); } if let Ok(json) = serde_json::to_string_pretty(self) { let _ = fs::write(path, json); } } } } #[cfg(test)] mod tests { use super::*; #[test] fn test_round_trip() { let original = AppConfig::default(); let serialized = serde_json::to_string(&original).unwrap(); let deserialized: AppConfig = serde_json::from_str(&serialized).unwrap(); assert_eq!(original, deserialized); } #[test] fn test_backward_compat_default_fill() { let minimal_json = r#"{"input_device":"","output_device":"","noise_gate_threshold":0.01}"#; let deserialized: AppConfig = serde_json::from_str(minimal_json).unwrap(); assert_eq!(deserialized.network_mode, NetworkMode::RelayNoDiscovery); assert!(!deserialized.echo_cancellation_enabled); assert!(deserialized.notifications_enabled); assert!(deserialized.custom_sound_self_join.is_none()); assert!(deserialized.custom_sound_peer_join.is_none()); assert!(deserialized.custom_sound_peer_leave.is_none()); assert!(deserialized.custom_sound_reconnect_attempt.is_none()); assert!(deserialized.custom_sound_reconnected.is_none()); assert!(deserialized.custom_sound_self_leave.is_none()); assert!(deserialized.custom_sound_mic_toggle.is_none()); assert!(deserialized.custom_sound_reconnect_failed.is_none()); } #[test] fn test_notifications_enabled_specifically() { let missing_notifications = r#"{"input_device":"","output_device":"","noise_gate_threshold":0.01}"#; let config_missing: AppConfig = serde_json::from_str(missing_notifications).unwrap(); assert!(config_missing.notifications_enabled); let explicit_false = r#"{"input_device":"","output_device":"","noise_gate_threshold":0.01,"notifications_enabled":false}"#; let config_false: AppConfig = serde_json::from_str(explicit_false).unwrap(); assert!(!config_false.notifications_enabled); let explicit_true = r#"{"input_device":"","output_device":"","noise_gate_threshold":0.01,"notifications_enabled":true}"#; let config_true: AppConfig = serde_json::from_str(explicit_true).unwrap(); assert!(config_true.notifications_enabled); } #[test] fn test_network_mode() { // NetworkMode::default() == RelayNoDiscovery assert_eq!(NetworkMode::default(), NetworkMode::RelayNoDiscovery); // ALL.len() == 3 and contains all three variants assert_eq!(NetworkMode::ALL.len(), 3); assert!(NetworkMode::ALL.contains(&NetworkMode::RelayNoDiscovery)); assert!(NetworkMode::ALL.contains(&NetworkMode::N0Full)); assert!(NetworkMode::ALL.contains(&NetworkMode::DirectOnly)); // each variant serde round-trips to itself for mode in NetworkMode::ALL { let serialized = serde_json::to_string(&mode).unwrap(); let deserialized: NetworkMode = serde_json::from_str(&serialized).unwrap(); assert_eq!(mode, deserialized); } // the three Display strings are non-empty and distinct let display_0 = NetworkMode::RelayNoDiscovery.to_string(); let display_1 = NetworkMode::N0Full.to_string(); let display_2 = NetworkMode::DirectOnly.to_string(); assert!(!display_0.is_empty()); assert!(!display_1.is_empty()); assert!(!display_2.is_empty()); assert_ne!(display_0, display_1); assert_ne!(display_1, display_2); assert_ne!(display_0, display_2); } #[test] fn test_unknown_field_tolerance() { // Unknown/extra field tolerance: a config JSON containing an extra unrecognized key should still deserialize. // Assert whatever actually happens and leave a comment; do not add deny_unknown_fields. let json_with_extra = r#"{ "input_device": "", "output_device": "", "noise_gate_threshold": 0.01, "unrecognized_field_xyz_123": "some_value" }"#; let deserialized_res: Result = serde_json::from_str(json_with_extra); // Assert that deserialization succeeds even with unrecognized/unknown fields. // This confirms that serde does not reject unknown fields (i.e. default behavior). assert!(deserialized_res.is_ok(), "Config deserialization failed when an unknown field was present"); let config = deserialized_res.unwrap(); assert_eq!(config.input_device, ""); assert_eq!(config.output_device, ""); assert_eq!(config.noise_gate_threshold, 0.01); } }