fix(cast): use target-local IP for media server

This commit is contained in:
vicrodh committed 2026-01-12 13:56:33 -06:00
1 parent 39acb0b59e
commit 39f6907fc1
4 files changed
+85 -18

No files matched your search

+38 -8
View File
@@ -18,6 +18,7 @@ pub struct CastState {
pub discovery: Arc<Mutex<DeviceDiscovery>>,
pub chromecast: ChromecastHandle,
pub media_server: Arc<Mutex<MediaServer>>,
pub connected_device_ip: Arc<Mutex<Option<String>>>,
}
impl CastState {
@@ -26,6 +27,7 @@ impl CastState {
discovery: Arc::new(Mutex::new(DeviceDiscovery::new())),
chromecast: ChromecastHandle::new(),
media_server: Arc::new(Mutex::new(MediaServer::start()?)),
connected_device_ip: Arc::new(Mutex::new(None)),
})
}
}
@@ -69,12 +71,26 @@ pub async fn cast_connect(device_id: String, state: State<'_, CastState>) -> Res
state
.chromecast
.connect(device.ip.clone(), device.port)
.map_err(|e| e.to_string())
.map_err(|e| e.to_string())?;
{
let mut connected = state.connected_device_ip.lock().await;
*connected = Some(device.ip.clone());
}
Ok(())
}
#[tauri::command]
pub async fn cast_disconnect(state: State<'_, CastState>) -> Result<(), String> {
state.chromecast.disconnect().map_err(|e| e.to_string())
state.chromecast.disconnect().map_err(|e| e.to_string())?;
{
let mut connected = state.connected_device_ip.lock().await;
*connected = None;
}
Ok(())
}
#[tauri::command]
@@ -110,12 +126,19 @@ pub async fn cast_play_track(
data
};
let target_ip = {
let connected = state.connected_device_ip.lock().await;
connected.clone()
};
let url = {
let mut server = 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())?
let url = match target_ip.as_deref() {
Some(ip) => server.get_audio_url_for_target(track_id, ip),
None => server.get_audio_url(track_id),
};
url.ok_or_else(|| "Failed to build media URL".to_string())?
};
state
@@ -137,14 +160,21 @@ pub async fn cast_play_local_track(
.ok_or_else(|| "Track not found".to_string())?
};
let target_ip = {
let connected = state.connected_device_ip.lock().await;
connected.clone()
};
let url = {
let mut server = state.media_server.lock().await;
server
.register_file(track_id as u64, &track.file_path)
.map_err(|e| e.to_string())?;
server
.get_audio_url(track_id as u64)
.ok_or_else(|| "Failed to build media URL".to_string())?
let url = match target_ip.as_deref() {
Some(ip) => server.get_audio_url_for_target(track_id as u64, ip),
None => server.get_audio_url(track_id as u64),
};
url.ok_or_else(|| "Failed to build media URL".to_string())?
};
let metadata = MediaMetadata {
+10 -3
View File
@@ -120,12 +120,19 @@ pub async fn dlna_play_track(
};
// Register with media server to get a URL the DLNA device can access
let target_ip = {
let connection = dlna_state.connection.lock().await;
connection.as_ref().map(|conn| conn.device_ip().to_string())
};
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())?
let url = match target_ip.as_deref() {
Some(ip) => server.get_audio_url_for_target(track_id, ip),
None => server.get_audio_url(track_id),
};
url.ok_or_else(|| "Failed to build media URL".to_string())?
};
// Load media on DLNA device
+4
View File
@@ -102,6 +102,10 @@ impl DlnaConnection {
}
}
pub fn device_ip(&self) -> &str {
&self.device.ip
}
/// Set the media URI and start playback
pub async fn load_media(&mut self, uri: &str, metadata: &DlnaMetadata) -> Result<(), DlnaError> {
if !self.connected {
+33 -7
View File
@@ -3,7 +3,7 @@
use std::collections::HashMap;
use std::fs::File;
use std::io::{Read, Seek, SeekFrom};
use std::net::{SocketAddr, UdpSocket};
use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
@@ -48,8 +48,8 @@ impl MediaServer {
.map(|addr| addr.port())
.ok_or_else(|| CastError::Server("Failed to determine HTTP port".to_string()))?;
let base_ip = local_ip().unwrap_or_else(|| "127.0.0.1".to_string());
let base_url = format!("http://{}:{}", base_ip, port);
let base_ip = local_ip().unwrap_or_else(|| IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));
let base_url = format_base_url(base_ip, port);
let entries = Arc::new(Mutex::new(HashMap::new()));
let shutdown = Arc::new(AtomicBool::new(false));
@@ -145,6 +145,20 @@ impl MediaServer {
None
}
/// Get full URL for registered audio using the local IP that can reach target_ip.
pub fn get_audio_url_for_target(&self, id: u64, target_ip: &str) -> Option<String> {
let entries = self.entries.lock().ok()?;
if !entries.contains_key(&id) {
return None;
}
let base_url = local_ip_for_target(target_ip)
.map(|ip| format_base_url(ip, self.port))
.unwrap_or_else(|| self.base_url.clone());
Some(format!("{}/audio/{}", base_url, id))
}
/// Get server port
pub fn port(&self) -> u16 {
self.port
@@ -280,12 +294,24 @@ fn header(name: &str, value: &str) -> Header {
Header::from_bytes(name, value).unwrap()
}
fn local_ip() -> Option<String> {
fn local_ip() -> Option<IpAddr> {
let socket = UdpSocket::bind("0.0.0.0:0").ok()?;
socket.connect("8.8.8.8:80").ok()?;
match socket.local_addr().ok()? {
SocketAddr::V4(addr) => Some(addr.ip().to_string()),
SocketAddr::V6(addr) => Some(addr.ip().to_string()),
socket.local_addr().ok().map(|addr| addr.ip())
}
fn local_ip_for_target(target_ip: &str) -> Option<IpAddr> {
let ip: IpAddr = target_ip.parse().ok()?;
let bind_addr = if ip.is_ipv4() { "0.0.0.0:0" } else { "[::]:0" };
let socket = UdpSocket::bind(bind_addr).ok()?;
socket.connect(SocketAddr::new(ip, 80)).ok()?;
socket.local_addr().ok().map(|addr| addr.ip())
}
fn format_base_url(ip: IpAddr, port: u16) -> String {
match ip {
IpAddr::V4(addr) => format!("http://{}:{}", addr, port),
IpAddr::V6(addr) => format!("http://[{}]:{}", addr, port),
}
}