Implement Chromecast frontend and DLNA AVTransport casting
Frontend: - Add castStore for managing cast state (connect, disconnect, play, pause, etc) - Update CastPicker to use castStore, show connected device banner with disconnect - Wire isCastConnected to NowPlayingBar and ExpandedPlayer for visual indicator - Modify playbackService to cast when connected instead of local playback DLNA Backend: - Implement full AVTransport SOAP client with: - SetAVTransportURI with DIDL-Lite metadata - Play, Pause, Stop, Seek actions - RenderingControl SetVolume - Add dlna_play_track command that fetches stream, downloads audio, and serves via media server - Share media server between Chromecast and DLNA
This commit is contained in:
1 parent
a4c09041a4
commit
1ac6d15551
8 files changed
+958
-76
No files matched your search
@@ -1,24 +1,29 @@
|
||||
//! Tauri commands for DLNA/UPnP casting (discovery + scaffolding)
|
||||
//! Tauri commands for DLNA/UPnP casting
|
||||
|
||||
use std::sync::Arc;
|
||||
use tauri::State;
|
||||
use tokio::sync::Mutex;
|
||||
|
||||
use crate::api::models::Quality;
|
||||
use crate::AppState;
|
||||
use crate::cast::dlna::{
|
||||
DiscoveredDlnaDevice, DlnaConnection, DlnaDiscovery, DlnaError, DlnaMetadata, DlnaStatus,
|
||||
};
|
||||
use crate::cast::MediaServer;
|
||||
|
||||
/// DLNA state shared across commands
|
||||
pub struct DlnaState {
|
||||
pub discovery: Arc<Mutex<DlnaDiscovery>>,
|
||||
pub connection: Arc<Mutex<Option<DlnaConnection>>>,
|
||||
pub media_server: Arc<Mutex<MediaServer>>,
|
||||
}
|
||||
|
||||
impl DlnaState {
|
||||
pub fn new() -> Result<Self, DlnaError> {
|
||||
pub fn new(media_server: Arc<Mutex<MediaServer>>) -> Result<Self, DlnaError> {
|
||||
Ok(Self {
|
||||
discovery: Arc::new(Mutex::new(DlnaDiscovery::new())),
|
||||
connection: Arc::new(Mutex::new(None)),
|
||||
media_server,
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -83,42 +88,134 @@ pub async fn dlna_get_status(state: State<'_, DlnaState>) -> Result<DlnaStatus,
|
||||
Ok(conn.get_status())
|
||||
}
|
||||
|
||||
// === Playback (stubs) ===
|
||||
// === Playback ===
|
||||
|
||||
/// Play a Qobuz track on the DLNA device
|
||||
#[tauri::command]
|
||||
pub async fn dlna_play_track(
|
||||
track_id: u64,
|
||||
metadata: DlnaMetadata,
|
||||
dlna_state: State<'_, DlnaState>,
|
||||
app_state: State<'_, AppState>,
|
||||
) -> Result<(), String> {
|
||||
// Get stream URL from Qobuz
|
||||
let stream_url = {
|
||||
let client = app_state.client.lock().await;
|
||||
client
|
||||
.get_stream_url_with_fallback(track_id, Quality::HiRes)
|
||||
.await
|
||||
.map_err(|e| format!("Failed to get stream URL: {}", e))?
|
||||
};
|
||||
|
||||
let content_type = stream_url.mime_type.clone();
|
||||
let cache = app_state.audio_cache.clone();
|
||||
|
||||
// Download audio data
|
||||
let audio_data = if let Some(cached) = cache.get(track_id) {
|
||||
cached.data
|
||||
} else {
|
||||
let data = download_audio(&stream_url.url).await?;
|
||||
cache.insert(track_id, data.clone());
|
||||
data
|
||||
};
|
||||
|
||||
// Register with media server to get a URL the DLNA device can access
|
||||
let url = {
|
||||
let mut server = dlna_state.media_server.lock().await;
|
||||
server.register_audio(track_id, audio_data, &content_type);
|
||||
server
|
||||
.get_audio_url(track_id)
|
||||
.ok_or_else(|| "Failed to build media URL".to_string())?
|
||||
};
|
||||
|
||||
// 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).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())?;
|
||||
conn.play().await.map_err(|e| e.to_string())?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Load media without starting playback (for compatibility with existing castStore)
|
||||
#[tauri::command]
|
||||
pub async fn dlna_load_media(
|
||||
metadata: DlnaMetadata,
|
||||
state: State<'_, DlnaState>,
|
||||
_metadata: DlnaMetadata,
|
||||
_state: State<'_, DlnaState>,
|
||||
) -> Result<(), String> {
|
||||
let mut connection = state.connection.lock().await;
|
||||
let conn = connection.as_mut().ok_or_else(|| "Not connected".to_string())?;
|
||||
conn.load_media(metadata).map_err(|e| e.to_string())
|
||||
// This is a stub - actual loading happens in dlna_play_track
|
||||
// The castStore calls this but we need the track_id for actual loading
|
||||
log::warn!("dlna_load_media called without track_id - use dlna_play_track instead");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[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())?;
|
||||
conn.play().map_err(|e| e.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())?;
|
||||
conn.pause().map_err(|e| e.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())?;
|
||||
conn.stop().map_err(|e| e.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())?;
|
||||
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())?;
|
||||
conn.set_volume(volume).map_err(|e| e.to_string())
|
||||
conn.set_volume(volume).await.map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
async fn download_audio(url: &str) -> Result<Vec<u8>, String> {
|
||||
use std::time::Duration;
|
||||
|
||||
let client = reqwest::Client::builder()
|
||||
.timeout(Duration::from_secs(120))
|
||||
.connect_timeout(Duration::from_secs(10))
|
||||
.build()
|
||||
.map_err(|e| format!("Failed to create HTTP client: {}", e))?;
|
||||
|
||||
let response = client
|
||||
.get(url)
|
||||
.header("User-Agent", "Mozilla/5.0")
|
||||
.send()
|
||||
.await
|
||||
.map_err(|e| format!("Failed to fetch audio: {}", e))?;
|
||||
|
||||
if !response.status().is_success() {
|
||||
return Err(format!("HTTP error: {}", response.status()));
|
||||
}
|
||||
|
||||
let bytes = response
|
||||
.bytes()
|
||||
.await
|
||||
.map_err(|e| format!("Failed to read audio bytes: {}", e))?;
|
||||
|
||||
Ok(bytes.to_vec())
|
||||
}
|
||||
@@ -1,6 +1,8 @@
|
||||
//! DLNA device connection and playback (placeholder)
|
||||
//! DLNA device connection and playback via AVTransport SOAP
|
||||
|
||||
use reqwest::Client;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::time::Duration;
|
||||
|
||||
use crate::cast::dlna::{DiscoveredDlnaDevice, DlnaError};
|
||||
|
||||
@@ -14,32 +16,78 @@ pub struct DlnaMetadata {
|
||||
pub duration_secs: Option<u64>,
|
||||
}
|
||||
|
||||
/// DLNA device status (minimal for now)
|
||||
/// DLNA device status
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct DlnaStatus {
|
||||
pub device_id: String,
|
||||
pub device_name: String,
|
||||
pub is_connected: bool,
|
||||
pub is_playing: bool,
|
||||
pub current_uri: Option<String>,
|
||||
}
|
||||
|
||||
/// DLNA connection stub (AVTransport integration pending)
|
||||
/// DLNA connection with AVTransport and RenderingControl support
|
||||
pub struct DlnaConnection {
|
||||
device: DiscoveredDlnaDevice,
|
||||
connected: bool,
|
||||
client: Client,
|
||||
// Service control URLs (discovered from device description)
|
||||
av_transport_url: Option<String>,
|
||||
rendering_control_url: Option<String>,
|
||||
// Current media URI
|
||||
current_uri: Option<String>,
|
||||
is_playing: bool,
|
||||
}
|
||||
|
||||
impl DlnaConnection {
|
||||
/// Connect to a DLNA device
|
||||
/// Connect to a DLNA device and discover service URLs
|
||||
pub fn connect(device: DiscoveredDlnaDevice) -> Result<Self, DlnaError> {
|
||||
let client = Client::builder()
|
||||
.timeout(Duration::from_secs(10))
|
||||
.build()
|
||||
.map_err(|e| DlnaError::Connection(format!("Failed to create HTTP client: {}", e)))?;
|
||||
|
||||
// For now, construct URLs based on device URL
|
||||
// The actual control URLs would come from parsing the device description XML
|
||||
let base_url = device.url.trim_end_matches('/');
|
||||
|
||||
// Common UPnP control URL patterns
|
||||
let av_transport_url = if device.has_av_transport {
|
||||
Some(format!("{}/AVTransport/control", base_url))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let rendering_control_url = if device.has_rendering_control {
|
||||
Some(format!("{}/RenderingControl/control", base_url))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
log::info!(
|
||||
"DLNA: Connected to {} (AVT: {:?}, RC: {:?})",
|
||||
device.name,
|
||||
av_transport_url.is_some(),
|
||||
rendering_control_url.is_some()
|
||||
);
|
||||
|
||||
Ok(Self {
|
||||
device,
|
||||
connected: true,
|
||||
client,
|
||||
av_transport_url,
|
||||
rendering_control_url,
|
||||
current_uri: None,
|
||||
is_playing: false,
|
||||
})
|
||||
}
|
||||
|
||||
/// Disconnect from the device
|
||||
pub fn disconnect(&mut self) -> Result<(), DlnaError> {
|
||||
self.connected = false;
|
||||
self.current_uri = None;
|
||||
self.is_playing = false;
|
||||
log::info!("DLNA: Disconnected from {}", self.device.name);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -49,39 +97,299 @@ impl DlnaConnection {
|
||||
device_id: self.device.id.clone(),
|
||||
device_name: self.device.name.clone(),
|
||||
is_connected: self.connected,
|
||||
is_playing: self.is_playing,
|
||||
current_uri: self.current_uri.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Load media (requires AVTransport integration)
|
||||
pub fn load_media(&mut self, _metadata: DlnaMetadata) -> Result<(), DlnaError> {
|
||||
Err(DlnaError::NotImplemented(
|
||||
"AVTransport integration not implemented".to_string(),
|
||||
))
|
||||
/// Set the media URI and start playback
|
||||
pub async fn load_media(&mut self, uri: &str, metadata: &DlnaMetadata) -> Result<(), DlnaError> {
|
||||
if !self.connected {
|
||||
return Err(DlnaError::NotConnected);
|
||||
}
|
||||
|
||||
/// Play/pause/stop controls
|
||||
pub fn play(&mut self) -> Result<(), DlnaError> {
|
||||
Err(DlnaError::NotImplemented(
|
||||
"AVTransport integration not implemented".to_string(),
|
||||
))
|
||||
let av_url = self.av_transport_url.as_ref()
|
||||
.ok_or_else(|| DlnaError::Playback("Device has no AVTransport service".to_string()))?;
|
||||
|
||||
// Build DIDL-Lite metadata
|
||||
let didl_metadata = build_didl_metadata(uri, metadata);
|
||||
|
||||
// SetAVTransportURI SOAP action
|
||||
let soap_body = format!(
|
||||
r#"<?xml version="1.0" encoding="utf-8"?>
|
||||
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
|
||||
<s:Body>
|
||||
<u:SetAVTransportURI xmlns:u="urn:schemas-upnp-org:service:AVTransport:1">
|
||||
<InstanceID>0</InstanceID>
|
||||
<CurrentURI>{}</CurrentURI>
|
||||
<CurrentURIMetaData>{}</CurrentURIMetaData>
|
||||
</u:SetAVTransportURI>
|
||||
</s:Body>
|
||||
</s:Envelope>"#,
|
||||
xml_escape(uri),
|
||||
xml_escape(&didl_metadata)
|
||||
);
|
||||
|
||||
self.send_soap_action(
|
||||
av_url,
|
||||
"urn:schemas-upnp-org:service:AVTransport:1#SetAVTransportURI",
|
||||
&soap_body,
|
||||
).await?;
|
||||
|
||||
self.current_uri = Some(uri.to_string());
|
||||
log::info!("DLNA: Set URI to {}", uri);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn pause(&mut self) -> Result<(), DlnaError> {
|
||||
Err(DlnaError::NotImplemented(
|
||||
"AVTransport integration not implemented".to_string(),
|
||||
))
|
||||
/// Start/resume playback
|
||||
pub async fn play(&mut self) -> Result<(), DlnaError> {
|
||||
if !self.connected {
|
||||
return Err(DlnaError::NotConnected);
|
||||
}
|
||||
|
||||
pub fn stop(&mut self) -> Result<(), DlnaError> {
|
||||
Err(DlnaError::NotImplemented(
|
||||
"AVTransport integration not implemented".to_string(),
|
||||
))
|
||||
let av_url = self.av_transport_url.as_ref()
|
||||
.ok_or_else(|| DlnaError::Playback("Device has no AVTransport service".to_string()))?;
|
||||
|
||||
let soap_body = r#"<?xml version="1.0" encoding="utf-8"?>
|
||||
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
|
||||
<s:Body>
|
||||
<u:Play xmlns:u="urn:schemas-upnp-org:service:AVTransport:1">
|
||||
<InstanceID>0</InstanceID>
|
||||
<Speed>1</Speed>
|
||||
</u:Play>
|
||||
</s:Body>
|
||||
</s:Envelope>"#;
|
||||
|
||||
self.send_soap_action(
|
||||
av_url,
|
||||
"urn:schemas-upnp-org:service:AVTransport:1#Play",
|
||||
soap_body,
|
||||
).await?;
|
||||
|
||||
self.is_playing = true;
|
||||
log::info!("DLNA: Play");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Volume control (0.0 - 1.0)
|
||||
pub fn set_volume(&mut self, _volume: f32) -> Result<(), DlnaError> {
|
||||
Err(DlnaError::NotImplemented(
|
||||
"RenderingControl integration not implemented".to_string(),
|
||||
))
|
||||
/// Pause playback
|
||||
pub async fn pause(&mut self) -> Result<(), DlnaError> {
|
||||
if !self.connected {
|
||||
return Err(DlnaError::NotConnected);
|
||||
}
|
||||
|
||||
let av_url = self.av_transport_url.as_ref()
|
||||
.ok_or_else(|| DlnaError::Playback("Device has no AVTransport service".to_string()))?;
|
||||
|
||||
let soap_body = r#"<?xml version="1.0" encoding="utf-8"?>
|
||||
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
|
||||
<s:Body>
|
||||
<u:Pause xmlns:u="urn:schemas-upnp-org:service:AVTransport:1">
|
||||
<InstanceID>0</InstanceID>
|
||||
</u:Pause>
|
||||
</s:Body>
|
||||
</s:Envelope>"#;
|
||||
|
||||
self.send_soap_action(
|
||||
av_url,
|
||||
"urn:schemas-upnp-org:service:AVTransport:1#Pause",
|
||||
soap_body,
|
||||
).await?;
|
||||
|
||||
self.is_playing = false;
|
||||
log::info!("DLNA: Pause");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Stop playback
|
||||
pub async fn stop(&mut self) -> Result<(), DlnaError> {
|
||||
if !self.connected {
|
||||
return Err(DlnaError::NotConnected);
|
||||
}
|
||||
|
||||
let av_url = self.av_transport_url.as_ref()
|
||||
.ok_or_else(|| DlnaError::Playback("Device has no AVTransport service".to_string()))?;
|
||||
|
||||
let soap_body = r#"<?xml version="1.0" encoding="utf-8"?>
|
||||
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
|
||||
<s:Body>
|
||||
<u:Stop xmlns:u="urn:schemas-upnp-org:service:AVTransport:1">
|
||||
<InstanceID>0</InstanceID>
|
||||
</u:Stop>
|
||||
</s:Body>
|
||||
</s:Envelope>"#;
|
||||
|
||||
self.send_soap_action(
|
||||
av_url,
|
||||
"urn:schemas-upnp-org:service:AVTransport:1#Stop",
|
||||
soap_body,
|
||||
).await?;
|
||||
|
||||
self.is_playing = false;
|
||||
self.current_uri = None;
|
||||
log::info!("DLNA: Stop");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Seek to position
|
||||
pub async fn seek(&mut self, position_secs: u64) -> Result<(), DlnaError> {
|
||||
if !self.connected {
|
||||
return Err(DlnaError::NotConnected);
|
||||
}
|
||||
|
||||
let av_url = self.av_transport_url.as_ref()
|
||||
.ok_or_else(|| DlnaError::Playback("Device has no AVTransport service".to_string()))?;
|
||||
|
||||
let hours = position_secs / 3600;
|
||||
let minutes = (position_secs % 3600) / 60;
|
||||
let seconds = position_secs % 60;
|
||||
let time_str = format!("{:02}:{:02}:{:02}", hours, minutes, seconds);
|
||||
|
||||
let soap_body = format!(
|
||||
r#"<?xml version="1.0" encoding="utf-8"?>
|
||||
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
|
||||
<s:Body>
|
||||
<u:Seek xmlns:u="urn:schemas-upnp-org:service:AVTransport:1">
|
||||
<InstanceID>0</InstanceID>
|
||||
<Unit>REL_TIME</Unit>
|
||||
<Target>{}</Target>
|
||||
</u:Seek>
|
||||
</s:Body>
|
||||
</s:Envelope>"#,
|
||||
time_str
|
||||
);
|
||||
|
||||
self.send_soap_action(
|
||||
av_url,
|
||||
"urn:schemas-upnp-org:service:AVTransport:1#Seek",
|
||||
&soap_body,
|
||||
).await?;
|
||||
|
||||
log::info!("DLNA: Seek to {}", time_str);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Set volume (0.0 - 1.0)
|
||||
pub async fn set_volume(&mut self, volume: f32) -> Result<(), DlnaError> {
|
||||
if !self.connected {
|
||||
return Err(DlnaError::NotConnected);
|
||||
}
|
||||
|
||||
let rc_url = self.rendering_control_url.as_ref()
|
||||
.ok_or_else(|| DlnaError::Playback("Device has no RenderingControl service".to_string()))?;
|
||||
|
||||
// DLNA volume is typically 0-100
|
||||
let dlna_volume = ((volume.clamp(0.0, 1.0) * 100.0) as u32).min(100);
|
||||
|
||||
let soap_body = format!(
|
||||
r#"<?xml version="1.0" encoding="utf-8"?>
|
||||
<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
|
||||
<s:Body>
|
||||
<u:SetVolume xmlns:u="urn:schemas-upnp-org:service:RenderingControl:1">
|
||||
<InstanceID>0</InstanceID>
|
||||
<Channel>Master</Channel>
|
||||
<DesiredVolume>{}</DesiredVolume>
|
||||
</u:SetVolume>
|
||||
</s:Body>
|
||||
</s:Envelope>"#,
|
||||
dlna_volume
|
||||
);
|
||||
|
||||
self.send_soap_action(
|
||||
rc_url,
|
||||
"urn:schemas-upnp-org:service:RenderingControl:1#SetVolume",
|
||||
&soap_body,
|
||||
).await?;
|
||||
|
||||
log::info!("DLNA: Set volume to {}", dlna_volume);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Send a SOAP action request
|
||||
async fn send_soap_action(
|
||||
&self,
|
||||
url: &str,
|
||||
action: &str,
|
||||
body: &str,
|
||||
) -> Result<String, DlnaError> {
|
||||
let response = self.client
|
||||
.post(url)
|
||||
.header("Content-Type", "text/xml; charset=utf-8")
|
||||
.header("SOAPAction", format!("\"{}\"", action))
|
||||
.body(body.to_string())
|
||||
.send()
|
||||
.await
|
||||
.map_err(|e| DlnaError::Playback(format!("SOAP request failed: {}", e)))?;
|
||||
|
||||
let status = response.status();
|
||||
let body = response.text().await
|
||||
.map_err(|e| DlnaError::Playback(format!("Failed to read response: {}", e)))?;
|
||||
|
||||
if !status.is_success() {
|
||||
log::error!("DLNA SOAP error ({}): {}", status, body);
|
||||
return Err(DlnaError::Playback(format!("SOAP error ({}): {}", status, parse_soap_error(&body))));
|
||||
}
|
||||
|
||||
Ok(body)
|
||||
}
|
||||
}
|
||||
|
||||
/// Build DIDL-Lite metadata for a track
|
||||
fn build_didl_metadata(uri: &str, metadata: &DlnaMetadata) -> String {
|
||||
let duration = metadata.duration_secs.map(|d| {
|
||||
let hours = d / 3600;
|
||||
let minutes = (d % 3600) / 60;
|
||||
let seconds = d % 60;
|
||||
format!("{:02}:{:02}:{:02}", hours, minutes, seconds)
|
||||
}).unwrap_or_else(|| "00:00:00".to_string());
|
||||
|
||||
let artwork = metadata.artwork_url.as_ref()
|
||||
.map(|url| format!(r#"<upnp:albumArtURI>{}</upnp:albumArtURI>"#, xml_escape(url)))
|
||||
.unwrap_or_default();
|
||||
|
||||
format!(
|
||||
r#"<DIDL-Lite xmlns="urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:upnp="urn:schemas-upnp-org:metadata-1-0/upnp/">
|
||||
<item id="0" parentID="-1" restricted="1">
|
||||
<dc:title>{}</dc:title>
|
||||
<dc:creator>{}</dc:creator>
|
||||
<upnp:album>{}</upnp:album>
|
||||
<upnp:artist>{}</upnp:artist>
|
||||
{}
|
||||
<res duration="{}" protocolInfo="http-get:*:audio/flac:*">{}</res>
|
||||
<upnp:class>object.item.audioItem.musicTrack</upnp:class>
|
||||
</item>
|
||||
</DIDL-Lite>"#,
|
||||
xml_escape(&metadata.title),
|
||||
xml_escape(&metadata.artist),
|
||||
xml_escape(&metadata.album),
|
||||
xml_escape(&metadata.artist),
|
||||
artwork,
|
||||
duration,
|
||||
xml_escape(uri)
|
||||
)
|
||||
}
|
||||
|
||||
/// Escape special XML characters
|
||||
fn xml_escape(s: &str) -> String {
|
||||
s.replace('&', "&")
|
||||
.replace('<', "<")
|
||||
.replace('>', ">")
|
||||
.replace('"', """)
|
||||
.replace('\'', "'")
|
||||
}
|
||||
|
||||
/// Parse error message from SOAP fault response
|
||||
fn parse_soap_error(body: &str) -> String {
|
||||
// Try to extract faultstring or errorDescription
|
||||
if let Some(start) = body.find("<faultstring>") {
|
||||
if let Some(end) = body.find("</faultstring>") {
|
||||
return body[start + 13..end].to_string();
|
||||
}
|
||||
}
|
||||
if let Some(start) = body.find("<errorDescription>") {
|
||||
if let Some(end) = body.find("</errorDescription>") {
|
||||
return body[start + 18..end].to_string();
|
||||
}
|
||||
}
|
||||
"Unknown error".to_string()
|
||||
}
|
||||
@@ -108,9 +108,10 @@ pub fn run() {
|
||||
.expect("Failed to initialize library database");
|
||||
|
||||
// Initialize casting state (Chromecast, DLNA, AirPlay)
|
||||
// CastState creates the media server, DLNA shares it
|
||||
let cast_state = cast::CastState::new()
|
||||
.expect("Failed to initialize Chromecast state");
|
||||
let dlna_state = cast::dlna::commands::DlnaState::new()
|
||||
let dlna_state = cast::dlna::commands::DlnaState::new(cast_state.media_server.clone())
|
||||
.expect("Failed to initialize DLNA state");
|
||||
let airplay_state = cast::airplay::commands::AirPlayState::new()
|
||||
.expect("Failed to initialize AirPlay state");
|
||||
@@ -361,10 +362,12 @@ pub fn run() {
|
||||
cast::dlna::commands::dlna_connect,
|
||||
cast::dlna::commands::dlna_disconnect,
|
||||
cast::dlna::commands::dlna_get_status,
|
||||
cast::dlna::commands::dlna_play_track,
|
||||
cast::dlna::commands::dlna_load_media,
|
||||
cast::dlna::commands::dlna_play,
|
||||
cast::dlna::commands::dlna_pause,
|
||||
cast::dlna::commands::dlna_stop,
|
||||
cast::dlna::commands::dlna_seek,
|
||||
cast::dlna::commands::dlna_set_volume,
|
||||
// AirPlay casting commands
|
||||
cast::airplay::commands::airplay_start_discovery,
|
||||
|
||||
@@ -1,24 +1,22 @@
|
||||
<script lang="ts">
|
||||
import { invoke } from '@tauri-apps/api/core';
|
||||
import { onMount, onDestroy } from 'svelte';
|
||||
import { X, Cast, Loader2, Monitor, Wifi, Tv, Speaker } from 'lucide-svelte';
|
||||
import { X, Cast, Loader2, Monitor, Wifi, Tv, Speaker, Power } from 'lucide-svelte';
|
||||
import {
|
||||
subscribe as subscribeCast,
|
||||
getCastState,
|
||||
connectToDevice,
|
||||
disconnect,
|
||||
type CastProtocol,
|
||||
type CastDevice
|
||||
} from '$lib/stores/castStore';
|
||||
|
||||
interface Props {
|
||||
isOpen: boolean;
|
||||
onClose: () => void;
|
||||
onConnect: (deviceId: string, protocol: CastProtocol) => void;
|
||||
}
|
||||
|
||||
type CastProtocol = 'chromecast' | 'dlna' | 'airplay';
|
||||
|
||||
interface CastDevice {
|
||||
id: string;
|
||||
name: string;
|
||||
ip: string;
|
||||
port: number;
|
||||
}
|
||||
|
||||
let { isOpen, onClose, onConnect }: Props = $props();
|
||||
let { isOpen, onClose }: Props = $props();
|
||||
|
||||
let activeProtocol = $state<CastProtocol>('chromecast');
|
||||
let chromecastDevices = $state<CastDevice[]>([]);
|
||||
@@ -27,6 +25,10 @@
|
||||
let loading = $state(false);
|
||||
let error = $state<string | null>(null);
|
||||
let discoveryStarted = $state(false);
|
||||
let connecting = $state(false);
|
||||
|
||||
// Cast state from store
|
||||
let castState = $state(getCastState());
|
||||
|
||||
const devices = $derived(() => {
|
||||
switch (activeProtocol) {
|
||||
@@ -36,13 +38,20 @@
|
||||
}
|
||||
});
|
||||
|
||||
let unsubscribeCast: (() => void) | null = null;
|
||||
|
||||
onMount(() => {
|
||||
unsubscribeCast = subscribeCast(() => {
|
||||
castState = getCastState();
|
||||
});
|
||||
|
||||
if (isOpen) {
|
||||
startDiscovery();
|
||||
}
|
||||
});
|
||||
|
||||
onDestroy(() => {
|
||||
unsubscribeCast?.();
|
||||
if (discoveryStarted) {
|
||||
stopDiscovery();
|
||||
}
|
||||
@@ -122,22 +131,23 @@
|
||||
}
|
||||
|
||||
async function handleConnect(device: CastDevice) {
|
||||
connecting = true;
|
||||
error = null;
|
||||
try {
|
||||
switch (activeProtocol) {
|
||||
case 'chromecast':
|
||||
await invoke('cast_connect', { deviceId: device.id });
|
||||
break;
|
||||
case 'dlna':
|
||||
await invoke('dlna_connect', { deviceId: device.id });
|
||||
break;
|
||||
case 'airplay':
|
||||
await invoke('airplay_connect', { deviceId: device.id });
|
||||
break;
|
||||
}
|
||||
onConnect(device.id, activeProtocol);
|
||||
await connectToDevice(device, activeProtocol);
|
||||
onClose();
|
||||
} catch (err) {
|
||||
error = String(err);
|
||||
} finally {
|
||||
connecting = false;
|
||||
}
|
||||
}
|
||||
|
||||
async function handleDisconnect() {
|
||||
try {
|
||||
await disconnect();
|
||||
} catch (err) {
|
||||
error = String(err);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -149,11 +159,11 @@
|
||||
}
|
||||
}
|
||||
|
||||
function getDeviceCount(protocol: CastProtocol): number {
|
||||
function getProtocolLabel(protocol: CastProtocol): string {
|
||||
switch (protocol) {
|
||||
case 'chromecast': return chromecastDevices.length;
|
||||
case 'dlna': return dlnaDevices.length;
|
||||
case 'airplay': return airplayDevices.length;
|
||||
case 'chromecast': return 'Chromecast';
|
||||
case 'dlna': return 'DLNA';
|
||||
case 'airplay': return 'AirPlay';
|
||||
}
|
||||
}
|
||||
</script>
|
||||
@@ -168,7 +178,23 @@
|
||||
</button>
|
||||
</div>
|
||||
|
||||
<!-- Protocol Tabs -->
|
||||
<!-- Connected Device Banner -->
|
||||
{#if castState.isConnected && castState.device}
|
||||
<div class="connected-banner">
|
||||
<div class="connected-info">
|
||||
<svelte:component this={getProtocolIcon(castState.protocol!)} size={20} />
|
||||
<div class="connected-text">
|
||||
<span class="connected-label">Connected to</span>
|
||||
<span class="connected-name">{castState.device.name}</span>
|
||||
</div>
|
||||
</div>
|
||||
<button class="disconnect-btn" onclick={handleDisconnect}>
|
||||
<Power size={16} />
|
||||
<span>Disconnect</span>
|
||||
</button>
|
||||
</div>
|
||||
{:else}
|
||||
<!-- Protocol Tabs (only show when not connected) -->
|
||||
<div class="protocol-tabs">
|
||||
<button
|
||||
class="protocol-tab"
|
||||
@@ -206,7 +232,12 @@
|
||||
</div>
|
||||
|
||||
<div class="content">
|
||||
{#if loading && devices().length === 0}
|
||||
{#if connecting}
|
||||
<div class="loading">
|
||||
<Loader2 size={32} class="spin" />
|
||||
<p>Connecting...</p>
|
||||
</div>
|
||||
{:else if loading && devices().length === 0}
|
||||
<div class="loading">
|
||||
<Loader2 size={32} class="spin" />
|
||||
<p>Searching for devices...</p>
|
||||
@@ -218,7 +249,7 @@
|
||||
{:else if devices().length === 0}
|
||||
<div class="empty">
|
||||
<Wifi size={32} />
|
||||
<p>No {activeProtocol === 'chromecast' ? 'Chromecast' : activeProtocol === 'dlna' ? 'DLNA' : 'AirPlay'} devices found</p>
|
||||
<p>No {getProtocolLabel(activeProtocol)} devices found</p>
|
||||
<p class="hint">Make sure devices are on the same network</p>
|
||||
</div>
|
||||
{:else}
|
||||
@@ -236,6 +267,7 @@
|
||||
</div>
|
||||
{/if}
|
||||
</div>
|
||||
{/if}
|
||||
</div>
|
||||
</div>
|
||||
{/if}
|
||||
@@ -416,4 +448,60 @@
|
||||
opacity: 1;
|
||||
color: var(--accent-primary);
|
||||
}
|
||||
|
||||
/* Connected Banner */
|
||||
.connected-banner {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: space-between;
|
||||
padding: 16px 20px;
|
||||
background: linear-gradient(135deg, rgba(34, 197, 94, 0.15) 0%, rgba(34, 197, 94, 0.05) 100%);
|
||||
border-bottom: 1px solid rgba(34, 197, 94, 0.2);
|
||||
}
|
||||
|
||||
.connected-info {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 12px;
|
||||
color: #22c55e;
|
||||
}
|
||||
|
||||
.connected-text {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 2px;
|
||||
}
|
||||
|
||||
.connected-label {
|
||||
font-size: 11px;
|
||||
color: rgba(34, 197, 94, 0.8);
|
||||
text-transform: uppercase;
|
||||
letter-spacing: 0.5px;
|
||||
}
|
||||
|
||||
.connected-name {
|
||||
font-size: 14px;
|
||||
font-weight: 600;
|
||||
color: var(--text-primary);
|
||||
}
|
||||
|
||||
.disconnect-btn {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 6px;
|
||||
padding: 8px 12px;
|
||||
background: rgba(239, 68, 68, 0.1);
|
||||
border: 1px solid rgba(239, 68, 68, 0.3);
|
||||
border-radius: 6px;
|
||||
color: #ef4444;
|
||||
font-size: 13px;
|
||||
font-weight: 500;
|
||||
cursor: pointer;
|
||||
transition: all 150ms ease;
|
||||
}
|
||||
|
||||
.disconnect-btn:hover {
|
||||
background: rgba(239, 68, 68, 0.2);
|
||||
border-color: rgba(239, 68, 68, 0.5);
|
||||
}
|
||||
</style>
|
||||
@@ -37,6 +37,7 @@
|
||||
onOpenQueue?: () => void;
|
||||
onOpenFocusMode?: () => void;
|
||||
onCast?: () => void;
|
||||
isCastConnected?: boolean;
|
||||
// Lyrics props
|
||||
lyricsLines?: LyricsLine[];
|
||||
lyricsActiveIndex?: number;
|
||||
@@ -75,6 +76,7 @@
|
||||
onOpenQueue,
|
||||
onOpenFocusMode,
|
||||
onCast,
|
||||
isCastConnected = false,
|
||||
lyricsLines = [],
|
||||
lyricsActiveIndex = -1,
|
||||
lyricsActiveProgress = 0,
|
||||
@@ -285,7 +287,12 @@
|
||||
<button class="action-btn" onclick={onOpenFocusMode} title="Focus Mode">
|
||||
<Maximize2 size={22} />
|
||||
</button>
|
||||
<button class="action-btn" onclick={onCast} title="Cast to device">
|
||||
<button
|
||||
class="action-btn"
|
||||
class:cast-active={isCastConnected}
|
||||
onclick={onCast}
|
||||
title={isCastConnected ? 'Casting - Click to manage' : 'Cast to device'}
|
||||
>
|
||||
<Cast size={22} />
|
||||
</button>
|
||||
<button
|
||||
@@ -659,6 +666,16 @@
|
||||
color: var(--accent-primary);
|
||||
}
|
||||
|
||||
.action-btn.cast-active {
|
||||
color: #22c55e;
|
||||
animation: cast-pulse 2s ease-in-out infinite;
|
||||
}
|
||||
|
||||
@keyframes cast-pulse {
|
||||
0%, 100% { opacity: 1; }
|
||||
50% { opacity: 0.6; }
|
||||
}
|
||||
|
||||
/* Right Section: Lyrics */
|
||||
.right-section {
|
||||
flex: 1;
|
||||
|
||||
@@ -18,6 +18,13 @@ import {
|
||||
} from '$lib/stores/playerStore';
|
||||
import { syncQueueState } from '$lib/stores/queueStore';
|
||||
import { logRecoEvent } from '$lib/services/recoService';
|
||||
import {
|
||||
isCasting,
|
||||
castTrack,
|
||||
castPlay,
|
||||
castPause,
|
||||
castStop
|
||||
} from '$lib/stores/castStore';
|
||||
|
||||
// ============ Types ============
|
||||
|
||||
@@ -66,12 +73,24 @@ export async function playTrack(
|
||||
showToast(track.title, 'buffering');
|
||||
}
|
||||
|
||||
// Use appropriate playback command
|
||||
// Check if we're casting to an external device
|
||||
if (isCasting() && !isLocal) {
|
||||
// Cast to connected device
|
||||
await castTrack(track.id, {
|
||||
title: track.title,
|
||||
artist: track.artist,
|
||||
album: track.album,
|
||||
artworkUrl: track.artwork,
|
||||
durationSecs: track.duration
|
||||
});
|
||||
} else {
|
||||
// Use appropriate local playback command
|
||||
if (isLocal) {
|
||||
await invoke('library_play_track', { trackId: track.id });
|
||||
} else {
|
||||
await invoke('play_track', { trackId: track.id });
|
||||
}
|
||||
}
|
||||
|
||||
// Dismiss buffering toast and show success
|
||||
dismissBuffering();
|
||||
|
||||
@@ -0,0 +1,334 @@
|
||||
/**
|
||||
* Cast Store
|
||||
*
|
||||
* Manages casting state across the app.
|
||||
* Tracks connected device and protocol.
|
||||
*/
|
||||
|
||||
import { invoke } from '@tauri-apps/api/core';
|
||||
|
||||
export type CastProtocol = 'chromecast' | 'dlna' | 'airplay';
|
||||
|
||||
export interface CastDevice {
|
||||
id: string;
|
||||
name: string;
|
||||
ip: string;
|
||||
port: number;
|
||||
}
|
||||
|
||||
interface CastState {
|
||||
isConnected: boolean;
|
||||
protocol: CastProtocol | null;
|
||||
device: CastDevice | null;
|
||||
isPlaying: boolean;
|
||||
currentTrackId: number | null;
|
||||
}
|
||||
|
||||
let state: CastState = {
|
||||
isConnected: false,
|
||||
protocol: null,
|
||||
device: null,
|
||||
isPlaying: false,
|
||||
currentTrackId: null
|
||||
};
|
||||
|
||||
const listeners = new Set<() => void>();
|
||||
|
||||
function notifyListeners(): void {
|
||||
for (const listener of listeners) {
|
||||
listener();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Subscribe to cast state changes
|
||||
*/
|
||||
export function subscribe(listener: () => void): () => void {
|
||||
listeners.add(listener);
|
||||
listener();
|
||||
return () => listeners.delete(listener);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get current cast state
|
||||
*/
|
||||
export function getCastState(): CastState {
|
||||
return { ...state };
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if currently casting
|
||||
*/
|
||||
export function isCasting(): boolean {
|
||||
return state.isConnected;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get connected device info
|
||||
*/
|
||||
export function getConnectedDevice(): CastDevice | null {
|
||||
return state.device;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get connected protocol
|
||||
*/
|
||||
export function getConnectedProtocol(): CastProtocol | null {
|
||||
return state.protocol;
|
||||
}
|
||||
|
||||
/**
|
||||
* Connect to a cast device
|
||||
*/
|
||||
export async function connectToDevice(device: CastDevice, protocol: CastProtocol): Promise<void> {
|
||||
try {
|
||||
switch (protocol) {
|
||||
case 'chromecast':
|
||||
await invoke('cast_connect', { deviceId: device.id });
|
||||
break;
|
||||
case 'dlna':
|
||||
await invoke('dlna_connect', { deviceId: device.id });
|
||||
break;
|
||||
case 'airplay':
|
||||
await invoke('airplay_connect', { deviceId: device.id });
|
||||
break;
|
||||
}
|
||||
|
||||
state = {
|
||||
...state,
|
||||
isConnected: true,
|
||||
protocol,
|
||||
device,
|
||||
isPlaying: false,
|
||||
currentTrackId: null
|
||||
};
|
||||
notifyListeners();
|
||||
} catch (err) {
|
||||
console.error('[CastStore] Failed to connect:', err);
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Disconnect from current device
|
||||
*/
|
||||
export async function disconnect(): Promise<void> {
|
||||
if (!state.isConnected || !state.protocol) return;
|
||||
|
||||
try {
|
||||
switch (state.protocol) {
|
||||
case 'chromecast':
|
||||
await invoke('cast_disconnect');
|
||||
break;
|
||||
case 'dlna':
|
||||
await invoke('dlna_disconnect');
|
||||
break;
|
||||
case 'airplay':
|
||||
await invoke('airplay_disconnect');
|
||||
break;
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('[CastStore] Failed to disconnect:', err);
|
||||
}
|
||||
|
||||
state = {
|
||||
isConnected: false,
|
||||
protocol: null,
|
||||
device: null,
|
||||
isPlaying: false,
|
||||
currentTrackId: null
|
||||
};
|
||||
notifyListeners();
|
||||
}
|
||||
|
||||
/**
|
||||
* Cast a track to the connected device
|
||||
*/
|
||||
export async function castTrack(
|
||||
trackId: number,
|
||||
metadata: {
|
||||
title: string;
|
||||
artist: string;
|
||||
album: string;
|
||||
artworkUrl?: string;
|
||||
durationSecs?: number;
|
||||
}
|
||||
): Promise<void> {
|
||||
if (!state.isConnected || !state.protocol) {
|
||||
throw new Error('Not connected to any cast device');
|
||||
}
|
||||
|
||||
try {
|
||||
switch (state.protocol) {
|
||||
case 'chromecast':
|
||||
await invoke('cast_play_track', {
|
||||
trackId,
|
||||
metadata: {
|
||||
title: metadata.title,
|
||||
artist: metadata.artist,
|
||||
album: metadata.album,
|
||||
artwork_url: metadata.artworkUrl,
|
||||
duration_secs: metadata.durationSecs
|
||||
}
|
||||
});
|
||||
break;
|
||||
case 'dlna':
|
||||
await invoke('dlna_play_track', {
|
||||
trackId: trackId,
|
||||
metadata: {
|
||||
title: metadata.title,
|
||||
artist: metadata.artist,
|
||||
album: metadata.album,
|
||||
artwork_url: metadata.artworkUrl,
|
||||
duration_secs: metadata.durationSecs
|
||||
}
|
||||
});
|
||||
break;
|
||||
case 'airplay':
|
||||
await invoke('airplay_load_media', {
|
||||
metadata: {
|
||||
title: metadata.title,
|
||||
artist: metadata.artist,
|
||||
album: metadata.album,
|
||||
artwork_url: metadata.artworkUrl,
|
||||
duration_secs: metadata.durationSecs
|
||||
}
|
||||
});
|
||||
await invoke('airplay_play');
|
||||
break;
|
||||
}
|
||||
|
||||
state = {
|
||||
...state,
|
||||
isPlaying: true,
|
||||
currentTrackId: trackId
|
||||
};
|
||||
notifyListeners();
|
||||
} catch (err) {
|
||||
console.error('[CastStore] Failed to cast track:', err);
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Play/resume on cast device
|
||||
*/
|
||||
export async function castPlay(): Promise<void> {
|
||||
if (!state.isConnected || !state.protocol) return;
|
||||
|
||||
try {
|
||||
switch (state.protocol) {
|
||||
case 'chromecast':
|
||||
await invoke('cast_play');
|
||||
break;
|
||||
case 'dlna':
|
||||
await invoke('dlna_play');
|
||||
break;
|
||||
case 'airplay':
|
||||
await invoke('airplay_play');
|
||||
break;
|
||||
}
|
||||
state = { ...state, isPlaying: true };
|
||||
notifyListeners();
|
||||
} catch (err) {
|
||||
console.error('[CastStore] Failed to play:', err);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Pause on cast device
|
||||
*/
|
||||
export async function castPause(): Promise<void> {
|
||||
if (!state.isConnected || !state.protocol) return;
|
||||
|
||||
try {
|
||||
switch (state.protocol) {
|
||||
case 'chromecast':
|
||||
await invoke('cast_pause');
|
||||
break;
|
||||
case 'dlna':
|
||||
await invoke('dlna_pause');
|
||||
break;
|
||||
case 'airplay':
|
||||
await invoke('airplay_pause');
|
||||
break;
|
||||
}
|
||||
state = { ...state, isPlaying: false };
|
||||
notifyListeners();
|
||||
} catch (err) {
|
||||
console.error('[CastStore] Failed to pause:', err);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Stop on cast device
|
||||
*/
|
||||
export async function castStop(): Promise<void> {
|
||||
if (!state.isConnected || !state.protocol) return;
|
||||
|
||||
try {
|
||||
switch (state.protocol) {
|
||||
case 'chromecast':
|
||||
await invoke('cast_stop');
|
||||
break;
|
||||
case 'dlna':
|
||||
await invoke('dlna_stop');
|
||||
break;
|
||||
case 'airplay':
|
||||
await invoke('airplay_stop');
|
||||
break;
|
||||
}
|
||||
state = { ...state, isPlaying: false, currentTrackId: null };
|
||||
notifyListeners();
|
||||
} catch (err) {
|
||||
console.error('[CastStore] Failed to stop:', err);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Seek on cast device
|
||||
*/
|
||||
export async function castSeek(positionSecs: number): Promise<void> {
|
||||
if (!state.isConnected || !state.protocol) return;
|
||||
|
||||
try {
|
||||
switch (state.protocol) {
|
||||
case 'chromecast':
|
||||
await invoke('cast_seek', { positionSecs });
|
||||
break;
|
||||
case 'dlna':
|
||||
// DLNA seek - will implement
|
||||
break;
|
||||
case 'airplay':
|
||||
// AirPlay seek - not implemented
|
||||
break;
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('[CastStore] Failed to seek:', err);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Set volume on cast device
|
||||
*/
|
||||
export async function castSetVolume(volume: number): Promise<void> {
|
||||
if (!state.isConnected || !state.protocol) return;
|
||||
|
||||
const normalizedVolume = Math.max(0, Math.min(1, volume / 100));
|
||||
|
||||
try {
|
||||
switch (state.protocol) {
|
||||
case 'chromecast':
|
||||
await invoke('cast_set_volume', { volume: normalizedVolume });
|
||||
break;
|
||||
case 'dlna':
|
||||
await invoke('dlna_set_volume', { volume: normalizedVolume });
|
||||
break;
|
||||
case 'airplay':
|
||||
await invoke('airplay_set_volume', { volume: normalizedVolume });
|
||||
break;
|
||||
}
|
||||
} catch (err) {
|
||||
console.error('[CastStore] Failed to set volume:', err);
|
||||
}
|
||||
}
|
||||
+19
-3
@@ -201,6 +201,13 @@
|
||||
type LyricsLine
|
||||
} from '$lib/stores/lyricsStore';
|
||||
|
||||
// Cast state management
|
||||
import {
|
||||
subscribe as subscribeCast,
|
||||
getCastState,
|
||||
isCasting
|
||||
} from '$lib/stores/castStore';
|
||||
|
||||
// Components
|
||||
import TitleBar from '$lib/components/TitleBar.svelte';
|
||||
import Sidebar from '$lib/components/Sidebar.svelte';
|
||||
@@ -247,6 +254,9 @@
|
||||
let isFocusModeOpen = $state(false);
|
||||
let isCastPickerOpen = $state(false);
|
||||
|
||||
// Cast State
|
||||
let isCastConnected = $state(false);
|
||||
|
||||
// Playlist Modal State (from uiStore subscription)
|
||||
let isPlaylistModalOpen = $state(false);
|
||||
let playlistModalMode = $state<'create' | 'edit' | 'addTrack'>('create');
|
||||
@@ -1288,6 +1298,11 @@
|
||||
lyricsSidebarVisible = state.sidebarVisible;
|
||||
});
|
||||
|
||||
// Subscribe to cast state changes
|
||||
const unsubscribeCast = subscribeCast(() => {
|
||||
isCastConnected = isCasting();
|
||||
});
|
||||
|
||||
// Start lyrics watcher for track changes
|
||||
startLyricsWatching();
|
||||
|
||||
@@ -1341,6 +1356,7 @@
|
||||
unsubscribePlayer();
|
||||
unsubscribeQueue();
|
||||
unsubscribeLyrics();
|
||||
unsubscribeCast();
|
||||
stopLyricsWatching();
|
||||
stopActiveLineUpdates();
|
||||
stopPolling();
|
||||
@@ -1576,6 +1592,7 @@
|
||||
onOpenFullScreen={openFullScreen}
|
||||
onOpenMiniPlayer={enterMiniplayerMode}
|
||||
onCast={openCastPicker}
|
||||
{isCastConnected}
|
||||
onToggleLyrics={toggleLyricsSidebar}
|
||||
lyricsActive={lyricsSidebarVisible}
|
||||
onArtistClick={() => {
|
||||
@@ -1599,6 +1616,7 @@
|
||||
onOpenFullScreen={openFullScreen}
|
||||
onOpenMiniPlayer={enterMiniplayerMode}
|
||||
onCast={openCastPicker}
|
||||
{isCastConnected}
|
||||
/>
|
||||
{/if}
|
||||
</div><!-- end app-body -->
|
||||
@@ -1652,6 +1670,7 @@
|
||||
openFocusMode();
|
||||
}}
|
||||
onCast={openCastPicker}
|
||||
{isCastConnected}
|
||||
lyricsLines={lyricsLines.map(l => ({ text: l.text }))}
|
||||
lyricsActiveIndex={lyricsActiveIndex}
|
||||
lyricsActiveProgress={lyricsActiveProgress}
|
||||
@@ -1722,9 +1741,6 @@
|
||||
<CastPicker
|
||||
isOpen={isCastPickerOpen}
|
||||
onClose={closeCastPicker}
|
||||
onConnect={(deviceId) => {
|
||||
showToast(`Connected to device`, 'success');
|
||||
}}
|
||||
/>
|
||||
</div>
|
||||
{/if}
|
||||
|
||||
Reference in new issue
Block a user