refactor(v2): internalize notification offline playlist reset and reco training flows
cx
This commit is contained in:
1 parent
0aecda77e5
commit
d2a13ba95e
1 file changed
+570
-60
+570
-60
@@ -21,7 +21,6 @@ use crate::cache::AudioCache;
|
|||||||
use crate::api_cache::ApiCacheState;
|
use crate::api_cache::ApiCacheState;
|
||||||
use crate::audio::{AlsaPlugin, AudioBackendType};
|
use crate::audio::{AlsaPlugin, AudioBackendType};
|
||||||
use crate::cast::{AirPlayMetadata, AirPlayState, CastState, DlnaMetadata, DlnaState, MediaMetadata};
|
use crate::cast::{AirPlayMetadata, AirPlayState, CastState, DlnaMetadata, DlnaState, MediaMetadata};
|
||||||
use crate::{commands as legacy_commands};
|
|
||||||
use crate::config::audio_settings::{AudioSettings, AudioSettingsState};
|
use crate::config::audio_settings::{AudioSettings, AudioSettingsState};
|
||||||
use crate::config::developer_settings::{DeveloperSettings, DeveloperSettingsState};
|
use crate::config::developer_settings::{DeveloperSettings, DeveloperSettingsState};
|
||||||
use crate::config::graphics_settings::{GraphicsSettings, GraphicsSettingsState, GraphicsStartupStatus};
|
use crate::config::graphics_settings::{GraphicsSettings, GraphicsSettingsState, GraphicsStartupStatus};
|
||||||
@@ -35,13 +34,18 @@ use crate::lyrics::LyricsState;
|
|||||||
use crate::musicbrainz::{CacheStats as MusicBrainzCacheStats, MusicBrainzSharedState};
|
use crate::musicbrainz::{CacheStats as MusicBrainzCacheStats, MusicBrainzSharedState};
|
||||||
use crate::offline::OfflineState;
|
use crate::offline::OfflineState;
|
||||||
use crate::offline_cache::OfflineCacheState;
|
use crate::offline_cache::OfflineCacheState;
|
||||||
use crate::{offline_cache as legacy_offline_cache};
|
|
||||||
use crate::playback_context::{ContentSource, ContextType, PlaybackContext};
|
use crate::playback_context::{ContentSource, ContextType, PlaybackContext};
|
||||||
use crate::queue::QueueTrack;
|
use crate::queue::QueueTrack;
|
||||||
use crate::reco_store::{RecoEventInput, RecoState};
|
use crate::reco_store::{RecoEventInput, RecoState};
|
||||||
use crate::runtime::{RuntimeManagerState, RuntimeStatus, RuntimeError, RuntimeEvent, DegradedReason, CommandRequirement};
|
use crate::runtime::{RuntimeManagerState, RuntimeStatus, RuntimeError, RuntimeEvent, DegradedReason, CommandRequirement};
|
||||||
use crate::{library as legacy_library};
|
|
||||||
use crate::AppState;
|
use crate::AppState;
|
||||||
|
use md5::{Digest, Md5};
|
||||||
|
use notify_rust::Notification;
|
||||||
|
use std::fs;
|
||||||
|
use std::io::Write;
|
||||||
|
use std::path::PathBuf;
|
||||||
|
use std::sync::Mutex;
|
||||||
|
use crate::{library as legacy_library};
|
||||||
|
|
||||||
// ==================== Helper Functions ====================
|
// ==================== Helper Functions ====================
|
||||||
|
|
||||||
@@ -169,6 +173,93 @@ async fn download_audio(url: &str) -> Result<Vec<u8>, String> {
|
|||||||
Ok(bytes.to_vec())
|
Ok(bytes.to_vec())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn v2_teardown_type_alias_state<S>(state: &Arc<Mutex<Option<S>>>) {
|
||||||
|
if let Ok(mut guard) = state.lock() {
|
||||||
|
*guard = None;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn v2_get_notification_artwork_cache_dir() -> Result<PathBuf, String> {
|
||||||
|
let cache_dir = dirs::cache_dir()
|
||||||
|
.ok_or_else(|| "Could not find cache directory".to_string())?
|
||||||
|
.join("qbz")
|
||||||
|
.join("artwork");
|
||||||
|
|
||||||
|
fs::create_dir_all(&cache_dir)
|
||||||
|
.map_err(|e| format!("Failed to create artwork cache dir: {}", e))?;
|
||||||
|
Ok(cache_dir)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn v2_resolve_local_artwork(url: &str) -> Option<PathBuf> {
|
||||||
|
if let Some(path) = url.strip_prefix("file://") {
|
||||||
|
return Some(PathBuf::from(path));
|
||||||
|
}
|
||||||
|
if let Some(path) = url.strip_prefix("asset://localhost/") {
|
||||||
|
let decoded = urlencoding::decode(path).ok()?;
|
||||||
|
return Some(PathBuf::from(decoded.into_owned()));
|
||||||
|
}
|
||||||
|
None
|
||||||
|
}
|
||||||
|
|
||||||
|
fn v2_cache_notification_artwork(url: &str) -> Result<PathBuf, String> {
|
||||||
|
if let Some(local_path) = v2_resolve_local_artwork(url) {
|
||||||
|
if local_path.exists() {
|
||||||
|
return Ok(local_path);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut hasher = Md5::new();
|
||||||
|
hasher.update(url.as_bytes());
|
||||||
|
let hash = format!("{:x}", hasher.finalize());
|
||||||
|
let cache_dir = v2_get_notification_artwork_cache_dir()?;
|
||||||
|
let cache_path = cache_dir.join(format!("{}.jpg", hash));
|
||||||
|
if cache_path.exists() {
|
||||||
|
return Ok(cache_path);
|
||||||
|
}
|
||||||
|
|
||||||
|
let response = reqwest::blocking::Client::new()
|
||||||
|
.get(url)
|
||||||
|
.timeout(std::time::Duration::from_secs(5))
|
||||||
|
.send()
|
||||||
|
.map_err(|e| format!("Failed to download artwork: {}", e))?;
|
||||||
|
|
||||||
|
if !response.status().is_success() {
|
||||||
|
return Err(format!("Failed to download artwork: HTTP {}", response.status()));
|
||||||
|
}
|
||||||
|
|
||||||
|
let bytes = response
|
||||||
|
.bytes()
|
||||||
|
.map_err(|e| format!("Failed to read artwork bytes: {}", e))?;
|
||||||
|
|
||||||
|
let mut file = fs::File::create(&cache_path)
|
||||||
|
.map_err(|e| format!("Failed to create artwork cache file: {}", e))?;
|
||||||
|
file.write_all(&bytes)
|
||||||
|
.map_err(|e| format!("Failed to write artwork cache: {}", e))?;
|
||||||
|
Ok(cache_path)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn v2_format_notification_quality(bit_depth: Option<u32>, sample_rate: Option<f64>) -> String {
|
||||||
|
match (bit_depth, sample_rate) {
|
||||||
|
(Some(bits), Some(rate)) if bits >= 24 || rate > 48.0 => {
|
||||||
|
let rate_str = if rate.fract() == 0.0 {
|
||||||
|
format!("{}", rate as u32)
|
||||||
|
} else {
|
||||||
|
format!("{}", rate)
|
||||||
|
};
|
||||||
|
format!("Hi-Res - {}-bit/{}kHz", bits, rate_str)
|
||||||
|
}
|
||||||
|
(Some(bits), Some(rate)) => {
|
||||||
|
let rate_str = if rate.fract() == 0.0 {
|
||||||
|
format!("{}", rate as u32)
|
||||||
|
} else {
|
||||||
|
format!("{}", rate)
|
||||||
|
};
|
||||||
|
format!("CD Quality - {}-bit/{}kHz", bits, rate_str)
|
||||||
|
}
|
||||||
|
_ => String::new(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// ==================== Runtime Contract Commands ====================
|
// ==================== Runtime Contract Commands ====================
|
||||||
|
|
||||||
/// Get current runtime status
|
/// Get current runtime status
|
||||||
@@ -2086,15 +2177,138 @@ pub async fn v2_reco_train_scores(
|
|||||||
max_per_type: Option<u32>,
|
max_per_type: Option<u32>,
|
||||||
state: State<'_, RecoState>,
|
state: State<'_, RecoState>,
|
||||||
) -> Result<(), String> {
|
) -> Result<(), String> {
|
||||||
crate::reco_store::commands::reco_train_scores(
|
use std::collections::HashMap;
|
||||||
lookback_days,
|
use std::time::{SystemTime, UNIX_EPOCH};
|
||||||
half_life_days,
|
|
||||||
max_events,
|
let lookback_days = lookback_days.unwrap_or(90);
|
||||||
max_per_type,
|
let half_life_days = half_life_days.unwrap_or(21.0);
|
||||||
state,
|
let max_events = max_events.unwrap_or(5000);
|
||||||
)
|
let max_per_type = max_per_type.unwrap_or(200);
|
||||||
.await
|
|
||||||
.map(|_| ())
|
let now_ts = SystemTime::now()
|
||||||
|
.duration_since(UNIX_EPOCH)
|
||||||
|
.map(|d| d.as_secs() as i64)
|
||||||
|
.unwrap_or(0);
|
||||||
|
let since_ts = now_ts.saturating_sub(lookback_days * 86_400);
|
||||||
|
|
||||||
|
let mut guard = state.db.lock().await;
|
||||||
|
let db = guard.as_mut().ok_or("No active session - please log in")?;
|
||||||
|
let events = db.get_events_since(since_ts, Some(max_events))?;
|
||||||
|
|
||||||
|
let decay_factor = |age_secs: i64| -> f64 {
|
||||||
|
if half_life_days <= 0.0 {
|
||||||
|
return 1.0;
|
||||||
|
}
|
||||||
|
let half_life_secs = half_life_days * 86_400.0;
|
||||||
|
let exponent = age_secs as f64 / half_life_secs;
|
||||||
|
0.5_f64.powf(exponent)
|
||||||
|
};
|
||||||
|
|
||||||
|
let event_weight = |event_type: &str| -> f64 {
|
||||||
|
match event_type {
|
||||||
|
"play" => 1.0,
|
||||||
|
"favorite" => 3.0,
|
||||||
|
"playlist_add" => 1.2,
|
||||||
|
_ => 1.0,
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
let item_weight = |item_type: &str, primary: bool| -> f64 {
|
||||||
|
if primary {
|
||||||
|
return 1.0;
|
||||||
|
}
|
||||||
|
match item_type {
|
||||||
|
"album" => 0.7,
|
||||||
|
"artist" => 0.5,
|
||||||
|
"track" => 0.85,
|
||||||
|
_ => 0.6,
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
let build_scores = |favorites_only: bool| {
|
||||||
|
let mut tracks: HashMap<u64, f64> = HashMap::new();
|
||||||
|
let mut albums: HashMap<String, f64> = HashMap::new();
|
||||||
|
let mut artists: HashMap<u64, f64> = HashMap::new();
|
||||||
|
|
||||||
|
for event in &events {
|
||||||
|
if favorites_only && event.event_type != "favorite" {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
let age_secs = (now_ts - event.created_at).max(0);
|
||||||
|
let base_weight = event_weight(&event.event_type) * decay_factor(age_secs);
|
||||||
|
|
||||||
|
if let Some(track_id) = event.track_id {
|
||||||
|
let weight = base_weight * item_weight("track", event.item_type == "track");
|
||||||
|
*tracks.entry(track_id).or_insert(0.0) += weight;
|
||||||
|
}
|
||||||
|
if let Some(album_id) = event.album_id.as_ref() {
|
||||||
|
let weight = base_weight * item_weight("album", event.item_type == "album");
|
||||||
|
*albums.entry(album_id.clone()).or_insert(0.0) += weight;
|
||||||
|
}
|
||||||
|
if let Some(artist_id) = event.artist_id {
|
||||||
|
let weight = base_weight * item_weight("artist", event.item_type == "artist");
|
||||||
|
*artists.entry(artist_id).or_insert(0.0) += weight;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
(tracks, albums, artists)
|
||||||
|
};
|
||||||
|
|
||||||
|
let build_track_entries = |scores: HashMap<u64, f64>| {
|
||||||
|
let mut entries: Vec<(u64, f64)> = scores.into_iter().collect();
|
||||||
|
entries.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
|
||||||
|
entries
|
||||||
|
.into_iter()
|
||||||
|
.take(max_per_type as usize)
|
||||||
|
.map(|(track_id, score)| crate::reco_store::db::RecoScoreEntry {
|
||||||
|
track_id: Some(track_id),
|
||||||
|
album_id: None,
|
||||||
|
artist_id: None,
|
||||||
|
score,
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
};
|
||||||
|
let build_album_entries = |scores: HashMap<String, f64>| {
|
||||||
|
let mut entries: Vec<(String, f64)> = scores.into_iter().collect();
|
||||||
|
entries.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
|
||||||
|
entries
|
||||||
|
.into_iter()
|
||||||
|
.take(max_per_type as usize)
|
||||||
|
.map(|(album_id, score)| crate::reco_store::db::RecoScoreEntry {
|
||||||
|
track_id: None,
|
||||||
|
album_id: Some(album_id),
|
||||||
|
artist_id: None,
|
||||||
|
score,
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
};
|
||||||
|
let build_artist_entries = |scores: HashMap<u64, f64>| {
|
||||||
|
let mut entries: Vec<(u64, f64)> = scores.into_iter().collect();
|
||||||
|
entries.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
|
||||||
|
entries
|
||||||
|
.into_iter()
|
||||||
|
.take(max_per_type as usize)
|
||||||
|
.map(|(artist_id, score)| crate::reco_store::db::RecoScoreEntry {
|
||||||
|
track_id: None,
|
||||||
|
album_id: None,
|
||||||
|
artist_id: Some(artist_id),
|
||||||
|
score,
|
||||||
|
})
|
||||||
|
.collect::<Vec<_>>()
|
||||||
|
};
|
||||||
|
|
||||||
|
let (all_tracks, all_albums, all_artists) = build_scores(false);
|
||||||
|
let (fav_tracks, fav_albums, fav_artists) = build_scores(true);
|
||||||
|
|
||||||
|
db.replace_scores("all", "track", &build_track_entries(all_tracks))?;
|
||||||
|
db.replace_scores("all", "album", &build_album_entries(all_albums))?;
|
||||||
|
db.replace_scores("all", "artist", &build_artist_entries(all_artists))?;
|
||||||
|
db.replace_scores("favorite", "track", &build_track_entries(fav_tracks))?;
|
||||||
|
db.replace_scores("favorite", "album", &build_album_entries(fav_albums))?;
|
||||||
|
db.replace_scores("favorite", "artist", &build_artist_entries(fav_artists))?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Debug, Clone, serde::Serialize)]
|
#[derive(Debug, Clone, serde::Serialize)]
|
||||||
@@ -4777,23 +4991,96 @@ pub fn v2_show_track_notification(
|
|||||||
bit_depth: Option<u32>,
|
bit_depth: Option<u32>,
|
||||||
sample_rate: Option<f64>,
|
sample_rate: Option<f64>,
|
||||||
) -> Result<(), String> {
|
) -> Result<(), String> {
|
||||||
legacy_commands::notification::show_track_notification(
|
log::info!("Command: v2_show_track_notification - {} by {}", title, artist);
|
||||||
title,
|
|
||||||
artist,
|
let mut lines = Vec::new();
|
||||||
album,
|
let mut line1_parts = Vec::new();
|
||||||
artwork_url,
|
if !artist.is_empty() {
|
||||||
bit_depth,
|
line1_parts.push(artist.clone());
|
||||||
sample_rate,
|
}
|
||||||
)
|
if !album.is_empty() {
|
||||||
|
line1_parts.push(album.clone());
|
||||||
|
}
|
||||||
|
if !line1_parts.is_empty() {
|
||||||
|
lines.push(line1_parts.join(" • "));
|
||||||
|
}
|
||||||
|
|
||||||
|
let quality = v2_format_notification_quality(bit_depth, sample_rate);
|
||||||
|
if !quality.is_empty() {
|
||||||
|
lines.push(quality);
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut notification = Notification::new();
|
||||||
|
notification.summary(&title).body(&lines.join("\n")).appname("QBZ").timeout(4000);
|
||||||
|
|
||||||
|
if let Some(url) = artwork_url {
|
||||||
|
if let Ok(path) = v2_cache_notification_artwork(&url) {
|
||||||
|
if let Some(path_str) = path.to_str() {
|
||||||
|
notification.image_path(path_str);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if let Err(e) = notification.show() {
|
||||||
|
log::warn!("Could not show notification (notification system may be unavailable): {}", e);
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
#[tauri::command]
|
#[tauri::command]
|
||||||
pub async fn v2_subscribe_playlist(
|
pub async fn v2_subscribe_playlist(
|
||||||
playlist_id: u64,
|
playlist_id: u64,
|
||||||
state: State<'_, AppState>,
|
state: State<'_, AppState>,
|
||||||
library_state: State<'_, legacy_library::commands::LibraryState>,
|
library_state: State<'_, crate::library::LibraryState>,
|
||||||
) -> Result<crate::api::models::Playlist, String> {
|
) -> Result<crate::api::models::Playlist, String> {
|
||||||
legacy_commands::playlist::subscribe_playlist(playlist_id, state, library_state).await
|
log::info!("Command: v2_subscribe_playlist {}", playlist_id);
|
||||||
|
let client = state.client.read().await;
|
||||||
|
|
||||||
|
let source = client
|
||||||
|
.get_playlist(playlist_id)
|
||||||
|
.await
|
||||||
|
.map_err(|e| format!("Failed to get source playlist: {}", e))?;
|
||||||
|
|
||||||
|
let track_ids: Vec<u64> = source
|
||||||
|
.tracks
|
||||||
|
.as_ref()
|
||||||
|
.map(|t| t.items.iter().map(|track| track.id).collect())
|
||||||
|
.unwrap_or_default();
|
||||||
|
if track_ids.is_empty() {
|
||||||
|
return Err("Source playlist has no tracks to copy".to_string());
|
||||||
|
}
|
||||||
|
|
||||||
|
let attribution = format!("\n\n---\nOriginally curated by {} on Qobuz", source.owner.name);
|
||||||
|
let new_description = match source.description {
|
||||||
|
Some(ref desc) if !desc.is_empty() => Some(format!("{}{}", desc, attribution)),
|
||||||
|
_ => Some(attribution.trim_start().to_string()),
|
||||||
|
};
|
||||||
|
|
||||||
|
let new_playlist = client
|
||||||
|
.create_playlist(&source.name, new_description.as_deref(), false)
|
||||||
|
.await
|
||||||
|
.map_err(|e| format!("Failed to create new playlist: {}", e))?;
|
||||||
|
|
||||||
|
client
|
||||||
|
.add_tracks_to_playlist(new_playlist.id, &track_ids)
|
||||||
|
.await
|
||||||
|
.map_err(|e| format!("Failed to add tracks to new playlist: {}", e))?;
|
||||||
|
|
||||||
|
if let Some(ref images) = source.images {
|
||||||
|
if let Some(image_url) = images.first() {
|
||||||
|
let db_guard = library_state.db.lock().await;
|
||||||
|
if let Some(ref db) = *db_guard {
|
||||||
|
if let Err(e) = db.update_playlist_artwork(new_playlist.id, Some(image_url)) {
|
||||||
|
log::warn!("Failed to save original playlist artwork: {}", e);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
client
|
||||||
|
.get_playlist(new_playlist.id)
|
||||||
|
.await
|
||||||
|
.map_err(|e| format!("Failed to fetch created playlist: {}", e))
|
||||||
}
|
}
|
||||||
|
|
||||||
#[tauri::command]
|
#[tauri::command]
|
||||||
@@ -4809,10 +5096,12 @@ pub async fn v2_cache_track_for_offline(
|
|||||||
sample_rate: Option<f64>,
|
sample_rate: Option<f64>,
|
||||||
state: State<'_, AppState>,
|
state: State<'_, AppState>,
|
||||||
cache_state: State<'_, OfflineCacheState>,
|
cache_state: State<'_, OfflineCacheState>,
|
||||||
library_state: State<'_, legacy_library::commands::LibraryState>,
|
library_state: State<'_, crate::library::LibraryState>,
|
||||||
app_handle: tauri::AppHandle,
|
app_handle: tauri::AppHandle,
|
||||||
) -> Result<(), String> {
|
) -> Result<(), String> {
|
||||||
legacy_offline_cache::commands::cache_track_for_offline(
|
log::info!("Command: v2_cache_track_for_offline {} - {} by {}", track_id, title, artist);
|
||||||
|
|
||||||
|
let track_info = crate::offline_cache::TrackCacheInfo {
|
||||||
track_id,
|
track_id,
|
||||||
title,
|
title,
|
||||||
artist,
|
artist,
|
||||||
@@ -4822,22 +5111,217 @@ pub async fn v2_cache_track_for_offline(
|
|||||||
quality,
|
quality,
|
||||||
bit_depth,
|
bit_depth,
|
||||||
sample_rate,
|
sample_rate,
|
||||||
state,
|
};
|
||||||
cache_state,
|
|
||||||
library_state,
|
let file_path = cache_state.track_file_path(track_id, "flac");
|
||||||
app_handle,
|
let file_path_str = file_path.to_string_lossy().to_string();
|
||||||
)
|
{
|
||||||
.await
|
let guard = cache_state.db.lock().await;
|
||||||
|
let db = guard.as_ref().ok_or("No active session - please log in")?;
|
||||||
|
db.insert_track(&track_info, &file_path_str)?;
|
||||||
|
}
|
||||||
|
|
||||||
|
let client = state.client.clone();
|
||||||
|
let fetcher = cache_state.fetcher.clone();
|
||||||
|
let db = cache_state.db.clone();
|
||||||
|
let offline_root = cache_state.get_cache_path();
|
||||||
|
let library_db = library_state.db.clone();
|
||||||
|
let app = app_handle.clone();
|
||||||
|
let semaphore = cache_state.cache_semaphore.clone();
|
||||||
|
|
||||||
|
tokio::spawn(async move {
|
||||||
|
let _permit = match semaphore.acquire_owned().await {
|
||||||
|
Ok(permit) => permit,
|
||||||
|
Err(err) => {
|
||||||
|
log::error!("Failed to acquire cache slot for track {}: {}", track_id, err);
|
||||||
|
if let Some(db_guard) = db.lock().await.as_ref() {
|
||||||
|
let _ = db_guard.update_status(
|
||||||
|
track_id,
|
||||||
|
crate::offline_cache::OfflineCacheStatus::Failed,
|
||||||
|
Some("Failed to start caching"),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
let _ = app.emit("offline:caching_failed", serde_json::json!({
|
||||||
|
"trackId": track_id,
|
||||||
|
"error": "Failed to acquire cache slot"
|
||||||
|
}));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
if let Some(db_guard) = db.lock().await.as_ref() {
|
||||||
|
let _ = db_guard.update_status(track_id, crate::offline_cache::OfflineCacheStatus::Downloading, None);
|
||||||
|
}
|
||||||
|
let _ = app.emit("offline:caching_started", serde_json::json!({ "trackId": track_id }));
|
||||||
|
|
||||||
|
let stream_url = {
|
||||||
|
let client_guard = client.read().await;
|
||||||
|
client_guard
|
||||||
|
.get_stream_url_with_fallback(track_id, crate::api::models::Quality::UltraHiRes)
|
||||||
|
.await
|
||||||
|
};
|
||||||
|
|
||||||
|
let url = match stream_url {
|
||||||
|
Ok(s) => s.url,
|
||||||
|
Err(e) => {
|
||||||
|
log::error!("Failed to get stream URL for track {}: {}", track_id, e);
|
||||||
|
if let Some(db_guard) = db.lock().await.as_ref() {
|
||||||
|
let _ = db_guard.update_status(
|
||||||
|
track_id,
|
||||||
|
crate::offline_cache::OfflineCacheStatus::Failed,
|
||||||
|
Some(&format!("Failed to get stream URL: {}", e)),
|
||||||
|
);
|
||||||
|
}
|
||||||
|
let _ = app.emit("offline:caching_failed", serde_json::json!({
|
||||||
|
"trackId": track_id,
|
||||||
|
"error": e.to_string()
|
||||||
|
}));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
match fetcher.fetch_to_file(&url, &file_path, track_id, Some(&app)).await {
|
||||||
|
Ok(size) => {
|
||||||
|
log::info!("Caching complete for track {}: {} bytes", track_id, size);
|
||||||
|
if let Some(db_guard) = db.lock().await.as_ref() {
|
||||||
|
let _ = db_guard.mark_complete(track_id, size);
|
||||||
|
}
|
||||||
|
let _ = app.emit("offline:caching_completed", serde_json::json!({
|
||||||
|
"trackId": track_id,
|
||||||
|
"size": size
|
||||||
|
}));
|
||||||
|
|
||||||
|
// Post-processing kept in V2 to avoid command->command delegation.
|
||||||
|
let file_path_str = file_path.to_string_lossy().to_string();
|
||||||
|
let qobuz_client = client.read().await;
|
||||||
|
let metadata = match crate::offline_cache::metadata::fetch_complete_metadata(track_id, &*qobuz_client).await {
|
||||||
|
Ok(m) => m,
|
||||||
|
Err(e) => {
|
||||||
|
log::warn!("Post-processing metadata fetch failed for {}: {}", track_id, e);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
if let Err(e) = crate::offline_cache::metadata::write_flac_tags(&file_path_str, &metadata) {
|
||||||
|
log::warn!("Failed to write tags for {}: {}", track_id, e);
|
||||||
|
}
|
||||||
|
if let Some(artwork_url) = &metadata.artwork_url {
|
||||||
|
if let Err(e) = crate::offline_cache::metadata::embed_artwork(&file_path_str, artwork_url).await {
|
||||||
|
log::warn!("Failed to embed artwork for {}: {}", track_id, e);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let new_path = match crate::offline_cache::metadata::organize_cached_file(
|
||||||
|
track_id,
|
||||||
|
&file_path_str,
|
||||||
|
&offline_root,
|
||||||
|
&metadata,
|
||||||
|
) {
|
||||||
|
Ok(p) => p,
|
||||||
|
Err(e) => {
|
||||||
|
log::warn!("Failed to organize cached file {}: {}", track_id, e);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
if let Some(artwork_url) = &metadata.artwork_url {
|
||||||
|
if let Some(parent_dir) = std::path::Path::new(&new_path).parent() {
|
||||||
|
let _ = crate::offline_cache::metadata::save_album_artwork(parent_dir, artwork_url).await;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
let (bit_depth_detected, sample_rate_detected) = match lofty::read_from_path(&new_path) {
|
||||||
|
Ok(tagged_file) => {
|
||||||
|
use lofty::AudioFile;
|
||||||
|
let properties = tagged_file.properties();
|
||||||
|
(
|
||||||
|
properties.bit_depth().map(|bd| bd as u32),
|
||||||
|
properties.sample_rate().map(|sr| sr as f64),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
Err(_) => (None, None),
|
||||||
|
};
|
||||||
|
|
||||||
|
let album_artist = metadata.album_artist.as_ref().unwrap_or(&metadata.artist);
|
||||||
|
let album_group_key = format!("{}|{}", metadata.album, album_artist);
|
||||||
|
let lib_opt = library_db.lock().await;
|
||||||
|
if let Some(lib_guard) = lib_opt.as_ref() {
|
||||||
|
let _ = lib_guard.insert_qobuz_cached_track_with_grouping(
|
||||||
|
track_id,
|
||||||
|
&metadata.title,
|
||||||
|
&metadata.artist,
|
||||||
|
Some(&metadata.album),
|
||||||
|
metadata.album_artist.as_deref(),
|
||||||
|
metadata.track_number,
|
||||||
|
metadata.disc_number,
|
||||||
|
metadata.year,
|
||||||
|
metadata.duration_secs,
|
||||||
|
&new_path,
|
||||||
|
&album_group_key,
|
||||||
|
&metadata.album,
|
||||||
|
bit_depth_detected,
|
||||||
|
sample_rate_detected,
|
||||||
|
None,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
if let Some(db_guard) = db.lock().await.as_ref() {
|
||||||
|
let _ = db_guard.update_file_path(track_id, &new_path);
|
||||||
|
}
|
||||||
|
|
||||||
|
let _ = app.emit("offline:caching_processed", serde_json::json!({
|
||||||
|
"trackId": track_id,
|
||||||
|
"path": new_path
|
||||||
|
}));
|
||||||
|
}
|
||||||
|
Err(e) => {
|
||||||
|
log::error!("Caching failed for track {}: {}", track_id, e);
|
||||||
|
if let Some(db_guard) = db.lock().await.as_ref() {
|
||||||
|
let _ = db_guard.update_status(track_id, crate::offline_cache::OfflineCacheStatus::Failed, Some(&e));
|
||||||
|
}
|
||||||
|
let _ = app.emit("offline:caching_failed", serde_json::json!({
|
||||||
|
"trackId": track_id,
|
||||||
|
"error": e
|
||||||
|
}));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
#[tauri::command]
|
#[tauri::command]
|
||||||
pub async fn v2_start_legacy_migration(
|
pub async fn v2_start_legacy_migration(
|
||||||
state: State<'_, AppState>,
|
state: State<'_, AppState>,
|
||||||
cache_state: State<'_, OfflineCacheState>,
|
cache_state: State<'_, OfflineCacheState>,
|
||||||
library_state: State<'_, legacy_library::commands::LibraryState>,
|
library_state: State<'_, crate::library::LibraryState>,
|
||||||
app_handle: tauri::AppHandle,
|
app_handle: tauri::AppHandle,
|
||||||
) -> Result<(), String> {
|
) -> Result<(), String> {
|
||||||
legacy_offline_cache::commands::start_legacy_migration(state, cache_state, library_state, app_handle).await
|
log::info!("Command: v2_start_legacy_migration");
|
||||||
|
let tracks_dir = cache_state.cache_dir.read().unwrap().join("tracks");
|
||||||
|
let track_ids = crate::offline_cache::detect_legacy_cached_files(&tracks_dir)?;
|
||||||
|
|
||||||
|
if track_ids.is_empty() {
|
||||||
|
return Err("No legacy cached files found".to_string());
|
||||||
|
}
|
||||||
|
|
||||||
|
let offline_root = cache_state.get_cache_path();
|
||||||
|
let qobuz_client = state.client.clone();
|
||||||
|
let library_db = library_state.db.clone();
|
||||||
|
let app_complete = app_handle.clone();
|
||||||
|
|
||||||
|
tokio::spawn(async move {
|
||||||
|
let status = crate::offline_cache::migrate_legacy_cached_files(
|
||||||
|
track_ids,
|
||||||
|
tracks_dir,
|
||||||
|
offline_root,
|
||||||
|
qobuz_client,
|
||||||
|
library_db,
|
||||||
|
)
|
||||||
|
.await;
|
||||||
|
let _ = app_complete.emit("migration:complete", status);
|
||||||
|
});
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
#[tauri::command]
|
#[tauri::command]
|
||||||
@@ -4910,7 +5394,7 @@ pub async fn v2_factory_reset(
|
|||||||
allowed_origins: State<'_, crate::config::remote_control_settings::AllowedOriginsState>,
|
allowed_origins: State<'_, crate::config::remote_control_settings::AllowedOriginsState>,
|
||||||
legal_settings: State<'_, crate::config::legal_settings::LegalSettingsState>,
|
legal_settings: State<'_, crate::config::legal_settings::LegalSettingsState>,
|
||||||
updates: State<'_, crate::updates::UpdatesState>,
|
updates: State<'_, crate::updates::UpdatesState>,
|
||||||
library: State<'_, legacy_library::commands::LibraryState>,
|
library: State<'_, crate::library::LibraryState>,
|
||||||
reco: State<'_, crate::reco_store::RecoState>,
|
reco: State<'_, crate::reco_store::RecoState>,
|
||||||
api_cache: State<'_, crate::api_cache::ApiCacheState>,
|
api_cache: State<'_, crate::api_cache::ApiCacheState>,
|
||||||
artist_vectors: State<'_, crate::artist_vectors::ArtistVectorStoreState>,
|
artist_vectors: State<'_, crate::artist_vectors::ArtistVectorStoreState>,
|
||||||
@@ -4921,33 +5405,59 @@ pub async fn v2_factory_reset(
|
|||||||
musicbrainz: State<'_, crate::musicbrainz::MusicBrainzSharedState>,
|
musicbrainz: State<'_, crate::musicbrainz::MusicBrainzSharedState>,
|
||||||
listenbrainz: State<'_, crate::listenbrainz::ListenBrainzSharedState>,
|
listenbrainz: State<'_, crate::listenbrainz::ListenBrainzSharedState>,
|
||||||
) -> Result<(), String> {
|
) -> Result<(), String> {
|
||||||
legacy_commands::factory_reset::factory_reset(
|
log::warn!("FACTORY RESET: Starting - all application data will be deleted");
|
||||||
app_state,
|
|
||||||
user_paths,
|
let _ = app_state.player.stop();
|
||||||
session_store,
|
app_state.media_controls.set_stopped();
|
||||||
favorites_cache,
|
|
||||||
subscription_state,
|
session_store.teardown();
|
||||||
playback_prefs,
|
let _ = favorites_cache.teardown();
|
||||||
favorites_prefs,
|
let _ = playback_prefs.teardown();
|
||||||
download_settings,
|
let _ = favorites_prefs.teardown();
|
||||||
audio_settings,
|
let _ = audio_settings.teardown();
|
||||||
tray_settings,
|
let _ = tray_settings.teardown();
|
||||||
remote_control_settings,
|
let _ = remote_control_settings.teardown();
|
||||||
allowed_origins,
|
let _ = allowed_origins.teardown();
|
||||||
legal_settings,
|
updates.teardown();
|
||||||
updates,
|
library.teardown().await;
|
||||||
library,
|
reco.teardown().await;
|
||||||
reco,
|
api_cache.teardown().await;
|
||||||
api_cache,
|
artist_vectors.teardown().await;
|
||||||
artist_vectors,
|
blacklist.teardown();
|
||||||
blacklist,
|
offline.teardown();
|
||||||
offline,
|
offline_cache.teardown().await;
|
||||||
offline_cache,
|
lyrics.teardown().await;
|
||||||
lyrics,
|
musicbrainz.teardown().await;
|
||||||
musicbrainz,
|
listenbrainz.teardown().await;
|
||||||
listenbrainz,
|
v2_teardown_type_alias_state(&*subscription_state);
|
||||||
)
|
v2_teardown_type_alias_state(&*download_settings);
|
||||||
.await
|
v2_teardown_type_alias_state(&*legal_settings);
|
||||||
|
|
||||||
|
user_paths.clear_user();
|
||||||
|
crate::user_data::UserDataPaths::clear_last_user_id();
|
||||||
|
|
||||||
|
if let Err(e) = crate::credentials::clear_qobuz_credentials() {
|
||||||
|
log::error!("FACTORY RESET: Failed to clear credentials: {}", e);
|
||||||
|
}
|
||||||
|
|
||||||
|
if let Ok(data_dir) = crate::user_data::UserDataPaths::global_data_dir() {
|
||||||
|
if data_dir.exists() {
|
||||||
|
let _ = std::fs::remove_dir_all(&data_dir);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if let Ok(cache_dir) = crate::user_data::UserDataPaths::global_cache_dir() {
|
||||||
|
if cache_dir.exists() {
|
||||||
|
let _ = std::fs::remove_dir_all(&cache_dir);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if let Some(config_dir) = dirs::config_dir().map(|d| d.join("qbz")) {
|
||||||
|
if config_dir.exists() {
|
||||||
|
let _ = std::fs::remove_dir_all(&config_dir);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
log::warn!("FACTORY RESET: Complete - all application data deleted");
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
#[tauri::command]
|
#[tauri::command]
|
||||||
|
|||||||
Reference in new issue
Block a user