style: apply cargo fmt across codebase

Automated formatting pass covering 79 Rust source files.
No logic changes -- only line wrapping, import ordering,
and match/closure reformatting.
This commit is contained in:
vicrodh committed 2026-02-20 00:14:58 -06:00
1 parent f9313c2d80
commit 3a297c0b2b
78 files changed
+4593 -2697

No files matched your search

+23 -10
View File
@@ -29,9 +29,7 @@ impl AirPlayState {
#[tauri::command]
pub async fn airplay_start_discovery(state: State<'_, AirPlayState>) -> Result<(), String> {
let mut discovery = state.discovery.lock().await;
discovery
.start_discovery()
.map_err(|e| e.to_string())
discovery.start_discovery().map_err(|e| e.to_string())
}
#[tauri::command]
@@ -51,7 +49,10 @@ pub async fn airplay_get_devices(
// === Connection ===
#[tauri::command]
pub async fn airplay_connect(device_id: String, state: State<'_, AirPlayState>) -> Result<(), String> {
pub async fn airplay_connect(
device_id: String,
state: State<'_, AirPlayState>,
) -> Result<(), String> {
let device = {
let discovery = state.discovery.lock().await;
discovery
@@ -79,7 +80,9 @@ pub async fn airplay_disconnect(state: State<'_, AirPlayState>) -> Result<(), St
#[tauri::command]
pub async fn airplay_get_status(state: State<'_, AirPlayState>) -> Result<AirPlayStatus, String> {
let connection = state.connection.lock().await;
let conn = connection.as_ref().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_ref()
.ok_or_else(|| "Not connected".to_string())?;
Ok(conn.get_status())
}
@@ -91,34 +94,44 @@ pub async fn airplay_load_media(
state: State<'_, AirPlayState>,
) -> Result<(), String> {
let mut connection = state.connection.lock().await;
let conn = connection.as_mut().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_mut()
.ok_or_else(|| "Not connected".to_string())?;
conn.load_media(metadata).map_err(|e| e.to_string())
}
#[tauri::command]
pub async fn airplay_play(state: State<'_, AirPlayState>) -> Result<(), String> {
let mut connection = state.connection.lock().await;
let conn = connection.as_mut().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_mut()
.ok_or_else(|| "Not connected".to_string())?;
conn.play().map_err(|e| e.to_string())
}
#[tauri::command]
pub async fn airplay_pause(state: State<'_, AirPlayState>) -> Result<(), String> {
let mut connection = state.connection.lock().await;
let conn = connection.as_mut().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_mut()
.ok_or_else(|| "Not connected".to_string())?;
conn.pause().map_err(|e| e.to_string())
}
#[tauri::command]
pub async fn airplay_stop(state: State<'_, AirPlayState>) -> Result<(), String> {
let mut connection = state.connection.lock().await;
let conn = connection.as_mut().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_mut()
.ok_or_else(|| "Not connected".to_string())?;
conn.stop().map_err(|e| e.to_string())
}
#[tauri::command]
pub async fn airplay_set_volume(volume: f32, state: State<'_, AirPlayState>) -> Result<(), String> {
let mut connection = state.connection.lock().await;
let conn = connection.as_mut().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_mut()
.ok_or_else(|| "Not connected".to_string())?;
conn.set_volume(volume).map_err(|e| e.to_string())
}
+2 -2
View File
@@ -6,8 +6,8 @@ pub mod commands;
// Re-export from qbz-cast
pub use qbz_cast::{
AirPlayConnection, AirPlayMetadata, AirPlayStatus, AirPlayDiscovery, DiscoveredAirPlayDevice,
AirPlayError,
AirPlayConnection, AirPlayDiscovery, AirPlayError, AirPlayMetadata, AirPlayStatus,
DiscoveredAirPlayDevice,
};
// Re-export Tauri command state
+35 -15
View File
@@ -5,12 +5,13 @@ use tauri::State;
use tokio::sync::Mutex;
use crate::api::models::Quality;
use crate::AppState;
use crate::cast::{
CastError, CastStatus, CastPositionInfo, DeviceDiscovery, DiscoveredDevice, MediaMetadata, MediaServer,
};
use crate::cast::chromecast_thread::ChromecastHandle;
use crate::cast::{
CastError, CastPositionInfo, CastStatus, DeviceDiscovery, DiscoveredDevice, MediaMetadata,
MediaServer,
};
use crate::library::{AudioFormat, LibraryState};
use crate::AppState;
/// Cast state shared across commands
/// Uses a dedicated thread for Chromecast operations since rust_cast is not thread-safe
@@ -49,9 +50,7 @@ impl CastState {
#[tauri::command]
pub async fn cast_start_discovery(state: State<'_, CastState>) -> Result<(), String> {
let mut discovery = state.discovery.lock().await;
discovery
.start_discovery()
.map_err(|e| e.to_string())
discovery.start_discovery().map_err(|e| e.to_string())
}
#[tauri::command]
@@ -112,7 +111,10 @@ pub async fn cast_get_status(state: State<'_, CastState>) -> Result<CastStatus,
#[tauri::command]
pub async fn cast_get_position(state: State<'_, CastState>) -> Result<CastPositionInfo, String> {
state.chromecast.get_media_position().map_err(|e| e.to_string())
state
.chromecast
.get_media_position()
.map_err(|e| e.to_string())
}
// === Playback ===
@@ -149,11 +151,16 @@ pub async fn cast_play_track(
};
// Ensure media server is started (lazy init)
state.get_or_create_media_server().await.map_err(|e| e.to_string())?;
state
.get_or_create_media_server()
.await
.map_err(|e| e.to_string())?;
let url = {
let mut server_guard = state.media_server.lock().await;
let server = server_guard.as_mut().ok_or("Media server not initialized")?;
let server = server_guard
.as_mut()
.ok_or("Media server not initialized")?;
server.register_audio(track_id, audio_data, &content_type);
let url = match target_ip.as_deref() {
Some(ip) => server.get_audio_url_for_target(track_id, ip),
@@ -176,7 +183,9 @@ pub async fn cast_play_local_track(
) -> Result<(), String> {
let track = {
let db_opt__ = library_state.db.lock().await;
let db = db_opt__.as_ref().ok_or("No active session - please log in")?;
let db = db_opt__
.as_ref()
.ok_or("No active session - please log in")?;
db.get_track(track_id)
.map_err(|e| e.to_string())?
.ok_or_else(|| "Track not found".to_string())?
@@ -188,11 +197,16 @@ pub async fn cast_play_local_track(
};
// Ensure media server is started (lazy init)
state.get_or_create_media_server().await.map_err(|e| e.to_string())?;
state
.get_or_create_media_server()
.await
.map_err(|e| e.to_string())?;
let url = {
let mut server_guard = state.media_server.lock().await;
let server = server_guard.as_mut().ok_or("Media server not initialized")?;
let server = server_guard
.as_mut()
.ok_or("Media server not initialized")?;
server
.register_file(track_id as u64, &track.file_path)
.map_err(|e| e.to_string())?;
@@ -236,12 +250,18 @@ pub async fn cast_stop(state: State<'_, CastState>) -> Result<(), String> {
#[tauri::command]
pub async fn cast_seek(position_secs: f64, state: State<'_, CastState>) -> Result<(), String> {
state.chromecast.seek(position_secs).map_err(|e| e.to_string())
state
.chromecast
.seek(position_secs)
.map_err(|e| e.to_string())
}
#[tauri::command]
pub async fn cast_set_volume(volume: f32, state: State<'_, CastState>) -> Result<(), String> {
state.chromecast.set_volume(volume).map_err(|e| e.to_string())
state
.chromecast
.set_volume(volume)
.map_err(|e| e.to_string())
}
async fn download_audio(url: &str) -> Result<Vec<u8>, String> {
+50 -21
View File
@@ -5,11 +5,12 @@ use tauri::State;
use tokio::sync::Mutex;
use crate::api::models::Quality;
use crate::AppState;
use crate::cast::dlna::{
DiscoveredDlnaDevice, DlnaConnection, DlnaDiscovery, DlnaError, DlnaMetadata, DlnaPositionInfo, DlnaStatus,
DiscoveredDlnaDevice, DlnaConnection, DlnaDiscovery, DlnaError, DlnaMetadata, DlnaPositionInfo,
DlnaStatus,
};
use crate::cast::MediaServer;
use crate::AppState;
/// DLNA state shared across commands
pub struct DlnaState {
@@ -46,10 +47,7 @@ impl DlnaState {
#[tauri::command]
pub async fn dlna_start_discovery(state: State<'_, DlnaState>) -> Result<(), String> {
let mut discovery = state.discovery.lock().await;
discovery
.start_discovery()
.await
.map_err(|e| e.to_string())
discovery.start_discovery().await.map_err(|e| e.to_string())
}
#[tauri::command]
@@ -78,7 +76,9 @@ pub async fn dlna_connect(device_id: String, state: State<'_, DlnaState>) -> Res
.map_err(|e| e.to_string())?
};
let connection = DlnaConnection::connect(device).await.map_err(|e| e.to_string())?;
let connection = DlnaConnection::connect(device)
.await
.map_err(|e| e.to_string())?;
let mut state_connection = state.connection.lock().await;
*state_connection = Some(connection);
Ok(())
@@ -97,7 +97,9 @@ pub async fn dlna_disconnect(state: State<'_, DlnaState>) -> Result<(), String>
#[tauri::command]
pub async fn dlna_get_status(state: State<'_, DlnaState>) -> Result<DlnaStatus, String> {
let connection = state.connection.lock().await;
let conn = connection.as_ref().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_ref()
.ok_or_else(|| "Not connected".to_string())?;
Ok(conn.get_status())
}
@@ -105,7 +107,9 @@ pub async fn dlna_get_status(state: State<'_, DlnaState>) -> Result<DlnaStatus,
#[tauri::command]
pub async fn dlna_get_position(state: State<'_, DlnaState>) -> Result<DlnaPositionInfo, String> {
let connection = state.connection.lock().await;
let conn = connection.as_ref().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_ref()
.ok_or_else(|| "Not connected".to_string())?;
conn.get_position_info().await.map_err(|e| e.to_string())
}
@@ -120,7 +124,7 @@ pub async fn dlna_play_track(
app_state: State<'_, AppState>,
) -> Result<(), String> {
log::info!("DLNA: dlna_play_track called for track_id={}", track_id);
// Get stream URL from Qobuz
let stream_url = {
let client = app_state.client.read().await;
@@ -149,11 +153,16 @@ pub async fn dlna_play_track(
};
// Ensure media server is started (lazy init)
dlna_state.ensure_media_server().await.map_err(|e| e.to_string())?;
dlna_state
.ensure_media_server()
.await
.map_err(|e| e.to_string())?;
let url = {
let mut server_guard = dlna_state.media_server.lock().await;
let server = server_guard.as_mut().ok_or("Media server not initialized")?;
let server = server_guard
.as_mut()
.ok_or("Media server not initialized")?;
server.register_audio(track_id, audio_data, &content_type);
let url = match target_ip.as_deref() {
Some(ip) => server.get_audio_url_for_target(track_id, ip),
@@ -162,20 +171,30 @@ pub async fn dlna_play_track(
url.ok_or_else(|| "Failed to build media URL".to_string())?
};
log::info!("DLNA: Playing track {} via MediaServer URL: {}", track_id, url);
log::info!(
"DLNA: Playing track {} via MediaServer URL: {}",
track_id,
url
);
log::info!("DLNA: Content-Type from Qobuz: {}", content_type);
// Load media on DLNA device
{
let mut connection = dlna_state.connection.lock().await;
let conn = connection.as_mut().ok_or_else(|| "Not connected".to_string())?;
conn.load_media(&url, &metadata, &content_type).await.map_err(|e| e.to_string())?;
let conn = connection
.as_mut()
.ok_or_else(|| "Not connected".to_string())?;
conn.load_media(&url, &metadata, &content_type)
.await
.map_err(|e| e.to_string())?;
}
// Start playback
{
let mut connection = dlna_state.connection.lock().await;
let conn = connection.as_mut().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_mut()
.ok_or_else(|| "Not connected".to_string())?;
conn.play().await.map_err(|e| e.to_string())?;
}
@@ -197,35 +216,45 @@ pub async fn dlna_load_media(
#[tauri::command]
pub async fn dlna_play(state: State<'_, DlnaState>) -> Result<(), String> {
let mut connection = state.connection.lock().await;
let conn = connection.as_mut().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_mut()
.ok_or_else(|| "Not connected".to_string())?;
conn.play().await.map_err(|e| e.to_string())
}
#[tauri::command]
pub async fn dlna_pause(state: State<'_, DlnaState>) -> Result<(), String> {
let mut connection = state.connection.lock().await;
let conn = connection.as_mut().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_mut()
.ok_or_else(|| "Not connected".to_string())?;
conn.pause().await.map_err(|e| e.to_string())
}
#[tauri::command]
pub async fn dlna_stop(state: State<'_, DlnaState>) -> Result<(), String> {
let mut connection = state.connection.lock().await;
let conn = connection.as_mut().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_mut()
.ok_or_else(|| "Not connected".to_string())?;
conn.stop().await.map_err(|e| e.to_string())
}
#[tauri::command]
pub async fn dlna_seek(position_secs: u64, state: State<'_, DlnaState>) -> Result<(), String> {
let mut connection = state.connection.lock().await;
let conn = connection.as_mut().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_mut()
.ok_or_else(|| "Not connected".to_string())?;
conn.seek(position_secs).await.map_err(|e| e.to_string())
}
#[tauri::command]
pub async fn dlna_set_volume(volume: f32, state: State<'_, DlnaState>) -> Result<(), String> {
let mut connection = state.connection.lock().await;
let conn = connection.as_mut().ok_or_else(|| "Not connected".to_string())?;
let conn = connection
.as_mut()
.ok_or_else(|| "Not connected".to_string())?;
conn.set_volume(volume).await.map_err(|e| e.to_string())
}
+2 -2
View File
@@ -6,8 +6,8 @@ pub mod commands;
// Re-export from qbz-cast
pub use qbz_cast::{
DlnaConnection, DlnaMetadata, DlnaPositionInfo, DlnaStatus, DlnaDiscovery,
DiscoveredDlnaDevice, DlnaError,
DiscoveredDlnaDevice, DlnaConnection, DlnaDiscovery, DlnaError, DlnaMetadata, DlnaPositionInfo,
DlnaStatus,
};
// Re-export Tauri command state
+1 -1
View File
@@ -2,4 +2,4 @@
//!
//! Re-exported from qbz-cast crate.
pub use qbz_cast::{CastError, AirPlayError, DlnaError};
pub use qbz_cast::{AirPlayError, CastError, DlnaError};
+8 -9
View File
@@ -3,26 +3,25 @@
//! This module provides Tauri commands for casting functionality.
//! The core casting logic is in the qbz-cast crate.
pub mod airplay;
pub mod chromecast_thread;
pub mod commands;
pub mod device;
pub mod discovery;
pub mod dlna;
pub mod errors;
pub mod media_server;
pub mod airplay;
pub mod dlna;
// Re-export from qbz-cast for internal use
pub use qbz_cast::{
CastError, CastDevice, CastDeviceConnection, CastStatus, MediaMetadata, CastPositionInfo,
DeviceDiscovery, DiscoveredDevice, MediaServer, ChromecastHandle, CastCommand,
AirPlayConnection, AirPlayDiscovery, AirPlayError, AirPlayMetadata, AirPlayStatus,
DiscoveredAirPlayDevice,
DlnaConnection, DlnaDiscovery, DlnaError, DlnaMetadata, DlnaStatus, DlnaPositionInfo,
DiscoveredDlnaDevice,
AirPlayConnection, AirPlayDiscovery, AirPlayError, AirPlayMetadata, AirPlayStatus, CastCommand,
CastDevice, CastDeviceConnection, CastError, CastPositionInfo, CastStatus, ChromecastHandle,
DeviceDiscovery, DiscoveredAirPlayDevice, DiscoveredDevice, DiscoveredDlnaDevice,
DlnaConnection, DlnaDiscovery, DlnaError, DlnaMetadata, DlnaPositionInfo, DlnaStatus,
MediaMetadata, MediaServer,
};
// Re-export Tauri command states
pub use commands::CastState;
pub use airplay::commands::AirPlayState;
pub use commands::CastState;
pub use dlna::commands::DlnaState;