Add offline mode track handling for playlists and queue
- Add batch check command for track local status in Rust - Show unavailable tracks with grayed-out visual state in PlaylistDetailView - Disable interactions for unavailable tracks (click, menu, play) - Add WifiOff indicator for unavailable tracks - Update QueuePanel to show unavailable track styling - Implement auto-skip for unavailable tracks during playback - Add offline mode sync to queue store - Add offline-specific filter states to PlaylistManager: - Available Offline - Partially Available - Not Available Offline (view-only) - Disable edit/drag for unavailable playlists in PlaylistManager - Add i18n strings for offline states (en/es)
This commit is contained in:
1 parent
6180fea08e
commit
6f3bcfe1cb
10 files changed
+490
-74
No files matched your search
@@ -409,6 +409,7 @@ pub fn run() {
|
||||
library::commands::playlist_get_local_content_status,
|
||||
library::commands::playlist_track_is_local,
|
||||
library::commands::playlist_get_local_track_id,
|
||||
library::commands::playlist_get_tracks_with_local_copies,
|
||||
library::commands::playlist_get_offline_available,
|
||||
// Chromecast casting commands
|
||||
cast::commands::cast_start_discovery,
|
||||
|
||||
@@ -1224,6 +1224,21 @@ pub async fn playlist_get_local_track_id(
|
||||
.map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
/// Batch check which tracks have local copies (for offline mode)
|
||||
/// Returns a list of track IDs that have local versions
|
||||
#[tauri::command]
|
||||
pub async fn playlist_get_tracks_with_local_copies(
|
||||
track_ids: Vec<u64>,
|
||||
state: State<'_, LibraryState>,
|
||||
) -> Result<Vec<u64>, String> {
|
||||
let db = state.db.lock().await;
|
||||
|
||||
let local_ids = db.get_tracks_with_local_copies(&track_ids)
|
||||
.map_err(|e| e.to_string())?;
|
||||
|
||||
Ok(local_ids.into_iter().collect())
|
||||
}
|
||||
|
||||
/// Get playlists that have local content (for offline mode filtering)
|
||||
#[tauri::command]
|
||||
pub async fn playlist_get_offline_available(
|
||||
|
||||
@@ -1713,6 +1713,48 @@ impl LibraryDatabase {
|
||||
.map_err(|e| LibraryError::Database(e.to_string()))
|
||||
}
|
||||
|
||||
/// Batch check which track IDs have local copies
|
||||
/// Returns a set of Qobuz track IDs that have local versions
|
||||
pub fn get_tracks_with_local_copies(&self, qobuz_track_ids: &[u64]) -> Result<std::collections::HashSet<u64>, LibraryError> {
|
||||
use std::collections::HashSet;
|
||||
|
||||
if qobuz_track_ids.is_empty() {
|
||||
return Ok(HashSet::new());
|
||||
}
|
||||
|
||||
// Build placeholders for IN clause
|
||||
let placeholders: Vec<String> = (1..=qobuz_track_ids.len())
|
||||
.map(|i| format!("?{}", i))
|
||||
.collect();
|
||||
let placeholders_str = placeholders.join(",");
|
||||
|
||||
let query = format!(
|
||||
"SELECT DISTINCT qobuz_track_id FROM local_tracks WHERE qobuz_track_id IN ({})",
|
||||
placeholders_str
|
||||
);
|
||||
|
||||
let mut stmt = self.conn.prepare(&query)
|
||||
.map_err(|e| LibraryError::Database(e.to_string()))?;
|
||||
|
||||
let params: Vec<rusqlite::types::Value> = qobuz_track_ids
|
||||
.iter()
|
||||
.map(|&id| rusqlite::types::Value::Integer(id as i64))
|
||||
.collect();
|
||||
|
||||
let rows = stmt.query_map(rusqlite::params_from_iter(params.iter()), |row| {
|
||||
row.get::<_, i64>(0)
|
||||
}).map_err(|e| LibraryError::Database(e.to_string()))?;
|
||||
|
||||
let mut result = HashSet::new();
|
||||
for row in rows {
|
||||
if let Ok(id) = row {
|
||||
result.insert(id as u64);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
/// Update the has_local_content status for a playlist
|
||||
pub fn update_playlist_local_content_status(
|
||||
&self,
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
<script lang="ts">
|
||||
import { X, GripVertical, Play, Search } from 'lucide-svelte';
|
||||
import { X, GripVertical, Play, Search, WifiOff } from 'lucide-svelte';
|
||||
import { t } from '$lib/i18n';
|
||||
|
||||
interface QueueTrack {
|
||||
@@ -8,6 +8,7 @@
|
||||
title: string;
|
||||
artist: string;
|
||||
duration: string;
|
||||
available?: boolean; // Whether track is available (false when offline without local copy)
|
||||
}
|
||||
|
||||
interface Props {
|
||||
@@ -96,13 +97,17 @@
|
||||
}
|
||||
|
||||
// Handle click only on non-drag-handle area
|
||||
function handleTrackClick(e: MouseEvent, trackId: string) {
|
||||
function handleTrackClick(e: MouseEvent, track: QueueTrack) {
|
||||
const target = e.target as HTMLElement;
|
||||
// Don't trigger play if clicking on drag handle
|
||||
if (target.closest('.drag-handle')) {
|
||||
return;
|
||||
}
|
||||
onPlayTrack?.(trackId);
|
||||
// Don't trigger play if track is unavailable
|
||||
if (track.available === false) {
|
||||
return;
|
||||
}
|
||||
onPlayTrack?.(track.id);
|
||||
}
|
||||
</script>
|
||||
|
||||
@@ -169,32 +174,41 @@
|
||||
<div class="tracks">
|
||||
{#each filteredTracks as track, index}
|
||||
{@const originalIndex = upcomingTracks.findIndex(t => t.id === track.id)}
|
||||
{@const isUnavailable = track.available === false}
|
||||
<div
|
||||
class="queue-track"
|
||||
class:hovered={hoveredTrack === track.id}
|
||||
class:hovered={hoveredTrack === track.id && !isUnavailable}
|
||||
class:dragging={draggedIndex === originalIndex}
|
||||
class:drag-over={dragOverIndex === originalIndex && draggedIndex !== originalIndex}
|
||||
draggable={canDrag}
|
||||
class:unavailable={isUnavailable}
|
||||
draggable={canDrag && !isUnavailable}
|
||||
onmouseenter={() => (hoveredTrack = track.id)}
|
||||
onmouseleave={() => (hoveredTrack = null)}
|
||||
onclick={(e) => handleTrackClick(e, track.id)}
|
||||
onclick={(e) => handleTrackClick(e, track)}
|
||||
ondragstart={(e) => handleDragStart(e, originalIndex)}
|
||||
ondragover={(e) => handleDragOver(e, originalIndex)}
|
||||
ondragleave={handleDragLeave}
|
||||
ondrop={(e) => handleDrop(e, originalIndex)}
|
||||
ondragend={handleDragEnd}
|
||||
role="button"
|
||||
tabindex="0"
|
||||
onkeydown={(e) => e.key === 'Enter' && onPlayTrack?.(track.id)}
|
||||
tabindex={isUnavailable ? -1 : 0}
|
||||
title={isUnavailable ? $t('offline.trackNotAvailable') : undefined}
|
||||
onkeydown={(e) => e.key === 'Enter' && !isUnavailable && onPlayTrack?.(track.id)}
|
||||
>
|
||||
<!-- Drag Handle -->
|
||||
<div class="drag-handle" class:visible={hoveredTrack === track.id && canDrag}>
|
||||
<GripVertical size={14} />
|
||||
</div>
|
||||
<!-- Unavailable Indicator or Drag Handle -->
|
||||
{#if isUnavailable}
|
||||
<div class="unavailable-indicator">
|
||||
<WifiOff size={14} />
|
||||
</div>
|
||||
{:else}
|
||||
<div class="drag-handle" class:visible={hoveredTrack === track.id && canDrag}>
|
||||
<GripVertical size={14} />
|
||||
</div>
|
||||
{/if}
|
||||
|
||||
<!-- Track Number / Play Icon -->
|
||||
<div class="track-number">
|
||||
{#if hoveredTrack === track.id}
|
||||
{#if hoveredTrack === track.id && !isUnavailable}
|
||||
<Play size={12} fill="white" color="white" />
|
||||
{:else}
|
||||
<span>{originalIndex + 1}</span>
|
||||
@@ -494,6 +508,27 @@
|
||||
opacity: 1;
|
||||
}
|
||||
|
||||
/* Unavailable track styles (offline mode) */
|
||||
.queue-track.unavailable {
|
||||
opacity: 0.4;
|
||||
cursor: not-allowed;
|
||||
pointer-events: none;
|
||||
}
|
||||
|
||||
.queue-track.unavailable .track-info,
|
||||
.queue-track.unavailable .track-number,
|
||||
.queue-track.unavailable .track-duration {
|
||||
filter: grayscale(100%);
|
||||
}
|
||||
|
||||
.unavailable-indicator {
|
||||
color: var(--text-muted);
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
width: 14px;
|
||||
}
|
||||
|
||||
.track-number {
|
||||
width: 28px;
|
||||
display: flex;
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
<script lang="ts">
|
||||
import { ArrowLeft, Play, Shuffle, ListMusic, Search, X, ChevronDown, ChevronRight, ImagePlus, HardDrive, Info, Edit3, BarChart2 } from 'lucide-svelte';
|
||||
import { ArrowLeft, Play, Shuffle, ListMusic, Search, X, ChevronDown, ChevronRight, ImagePlus, HardDrive, Info, Edit3, BarChart2, WifiOff } from 'lucide-svelte';
|
||||
import AlbumMenu from '../AlbumMenu.svelte';
|
||||
import PlaylistCollage from '../PlaylistCollage.svelte';
|
||||
import PlaylistModal from '../PlaylistModal.svelte';
|
||||
@@ -8,6 +8,13 @@
|
||||
import { open } from '@tauri-apps/plugin-dialog';
|
||||
import TrackRow from '../TrackRow.svelte';
|
||||
import { type DownloadStatus } from '$lib/stores/downloadState';
|
||||
import {
|
||||
subscribe as subscribeOffline,
|
||||
getStatus as getOfflineStatus,
|
||||
type OfflineStatus
|
||||
} from '$lib/stores/offlineStore';
|
||||
import { t } from '$lib/i18n';
|
||||
import { onMount } from 'svelte';
|
||||
|
||||
interface PlaylistTrack {
|
||||
id: number;
|
||||
@@ -147,6 +154,10 @@
|
||||
let error = $state<string | null>(null);
|
||||
let playBtnHovered = $state(false);
|
||||
|
||||
// Offline mode state
|
||||
let offlineStatus = $state<OfflineStatus>(getOfflineStatus());
|
||||
let tracksWithLocalCopies = $state<Set<number>>(new Set());
|
||||
|
||||
// Local settings state
|
||||
let searchQuery = $state('');
|
||||
let sortBy = $state<SortField>('default');
|
||||
@@ -157,6 +168,49 @@
|
||||
let playlistStats = $state<PlaylistStats | null>(null);
|
||||
let editModalOpen = $state(false);
|
||||
|
||||
// Subscribe to offline status changes
|
||||
onMount(() => {
|
||||
const unsubscribe = subscribeOffline(() => {
|
||||
offlineStatus = getOfflineStatus();
|
||||
// Re-check local copies when offline status changes
|
||||
if (offlineStatus.isOffline && tracks.length > 0) {
|
||||
checkTracksLocalStatus();
|
||||
}
|
||||
});
|
||||
return unsubscribe;
|
||||
});
|
||||
|
||||
// Check if a track is available (has local copy when offline, always available when online)
|
||||
function isTrackAvailable(track: DisplayTrack): boolean {
|
||||
if (!offlineStatus.isOffline) return true;
|
||||
if (track.isLocal) return true; // Local tracks are always available
|
||||
return tracksWithLocalCopies.has(track.id);
|
||||
}
|
||||
|
||||
// Check which tracks have local copies (for offline mode)
|
||||
async function checkTracksLocalStatus() {
|
||||
if (!offlineStatus.isOffline || tracks.length === 0) {
|
||||
tracksWithLocalCopies = new Set();
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
const qobuzTrackIds = tracks.filter(t => !t.isLocal).map(t => t.id);
|
||||
if (qobuzTrackIds.length === 0) {
|
||||
tracksWithLocalCopies = new Set();
|
||||
return;
|
||||
}
|
||||
|
||||
const localIds = await invoke<number[]>('playlist_get_tracks_with_local_copies', {
|
||||
trackIds: qobuzTrackIds
|
||||
});
|
||||
tracksWithLocalCopies = new Set(localIds);
|
||||
} catch (err) {
|
||||
console.error('Failed to check local track status:', err);
|
||||
tracksWithLocalCopies = new Set();
|
||||
}
|
||||
}
|
||||
|
||||
// Reload playlist when playlistId changes
|
||||
$effect(() => {
|
||||
// Access playlistId to create dependency
|
||||
@@ -167,6 +221,13 @@
|
||||
loadStats();
|
||||
});
|
||||
|
||||
// Check local track status after loading tracks and when offline
|
||||
$effect(() => {
|
||||
if (offlineStatus.isOffline && tracks.length > 0) {
|
||||
checkTracksLocalStatus();
|
||||
}
|
||||
});
|
||||
|
||||
async function loadLocalTracks() {
|
||||
try {
|
||||
const result = await invoke<LocalLibraryTrack[]>('playlist_get_local_tracks', { playlistId });
|
||||
@@ -720,11 +781,21 @@
|
||||
? (track.localTrackId !== undefined && activeTrackId === track.localTrackId)
|
||||
: activeTrackId === track.id
|
||||
)}
|
||||
<div class="track-row-wrapper" class:is-local={track.isLocal}>
|
||||
{@const available = isTrackAvailable(track)}
|
||||
<div
|
||||
class="track-row-wrapper"
|
||||
class:is-local={track.isLocal}
|
||||
class:unavailable={!available}
|
||||
title={!available ? $t('offline.trackNotAvailable') : undefined}
|
||||
>
|
||||
{#if track.isLocal}
|
||||
<div class="local-indicator" title="Local track">
|
||||
<HardDrive size={12} />
|
||||
</div>
|
||||
{:else if !available}
|
||||
<div class="unavailable-indicator" title={$t('offline.trackNotAvailable')}>
|
||||
<WifiOff size={12} />
|
||||
</div>
|
||||
{/if}
|
||||
<TrackRow
|
||||
trackId={track.isLocal ? undefined : track.id}
|
||||
@@ -739,14 +810,14 @@
|
||||
? 'Hi-Res'
|
||||
: '-'}
|
||||
isPlaying={isActiveTrack}
|
||||
hideFavorite={track.isLocal}
|
||||
hideDownload={track.isLocal}
|
||||
hideFavorite={track.isLocal || !available}
|
||||
hideDownload={track.isLocal || !available}
|
||||
downloadStatus={downloadInfo.status}
|
||||
downloadProgress={downloadInfo.progress}
|
||||
onPlay={() => handleTrackClick(track)}
|
||||
onDownload={!track.isLocal && onTrackDownload ? () => onTrackDownload(track) : undefined}
|
||||
onRemoveDownload={!track.isLocal && onTrackRemoveDownload ? () => onTrackRemoveDownload(track.id) : undefined}
|
||||
menuActions={{
|
||||
onPlay={available ? () => handleTrackClick(track) : undefined}
|
||||
onDownload={available && !track.isLocal && onTrackDownload ? () => onTrackDownload(track) : undefined}
|
||||
onRemoveDownload={available && !track.isLocal && onTrackRemoveDownload ? () => onTrackRemoveDownload(track.id) : undefined}
|
||||
menuActions={available ? {
|
||||
onPlayNow: () => handleTrackClick(track),
|
||||
onPlayNext: track.isLocal ? () => handleTrackPlayNext(track) : (onTrackPlayNext ? () => onTrackPlayNext(track) : undefined),
|
||||
onPlayLater: track.isLocal ? () => handleTrackPlayLater(track) : (onTrackPlayLater ? () => onTrackPlayLater(track) : undefined),
|
||||
@@ -755,7 +826,7 @@
|
||||
onShareSonglink: !track.isLocal && onTrackShareSonglink ? () => onTrackShareSonglink(track) : undefined,
|
||||
onGoToAlbum: !track.isLocal && track.albumId && onTrackGoToAlbum ? () => onTrackGoToAlbum(track.albumId!) : undefined,
|
||||
onGoToArtist: !track.isLocal && track.artistId && onTrackGoToArtist ? () => onTrackGoToArtist(track.artistId!) : undefined
|
||||
}}
|
||||
} : {}}
|
||||
/>
|
||||
{#if track.isLocal}
|
||||
<button class="remove-local-btn" onclick={() => removeLocalTrack(track)} title="Remove from playlist">
|
||||
@@ -1334,6 +1405,28 @@
|
||||
color: var(--accent-primary);
|
||||
}
|
||||
|
||||
/* Unavailable track styles (offline mode) */
|
||||
.track-row-wrapper.unavailable {
|
||||
padding-left: 24px;
|
||||
opacity: 0.4;
|
||||
pointer-events: none;
|
||||
user-select: none;
|
||||
}
|
||||
|
||||
.track-row-wrapper.unavailable :global(.track-row) {
|
||||
filter: grayscale(100%);
|
||||
}
|
||||
|
||||
.unavailable-indicator {
|
||||
position: absolute;
|
||||
left: 0;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
width: 20px;
|
||||
color: var(--text-muted);
|
||||
}
|
||||
|
||||
.remove-local-btn {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
|
||||
@@ -37,7 +37,7 @@
|
||||
last_played_at?: number;
|
||||
}
|
||||
|
||||
type PlaylistFilter = 'all' | 'visible' | 'hidden';
|
||||
type PlaylistFilter = 'all' | 'visible' | 'hidden' | 'offline_all' | 'offline_partial' | 'offline_unavailable';
|
||||
type PlaylistSort = 'name' | 'recent' | 'playcount' | 'custom';
|
||||
type ViewMode = 'list' | 'grid';
|
||||
|
||||
@@ -88,33 +88,63 @@
|
||||
$effect(() => { localStorage.setItem('qbz-pm-sort', sort); });
|
||||
$effect(() => { localStorage.setItem('qbz-pm-view', viewMode); });
|
||||
|
||||
// Check if a playlist is available for interaction in offline mode
|
||||
function isPlaylistAvailableOffline(playlistId: number): boolean {
|
||||
if (!offlineStatus.isOffline) return true;
|
||||
const localStatus = playlistSettings.get(playlistId)?.hasLocalContent ?? 'unknown';
|
||||
if (localStatus === 'all_local') return true;
|
||||
if (localStatus === 'some_local' && offlineSettings.showPartialPlaylists) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
// Filtered and sorted playlists
|
||||
const displayPlaylists = $derived.by(() => {
|
||||
let result = [...playlists];
|
||||
|
||||
// Apply offline filter first - only show playlists with local content
|
||||
if (offlineStatus.isOffline) {
|
||||
result = result.filter(p => {
|
||||
const settings = playlistSettings.get(p.id);
|
||||
const localStatus = settings?.hasLocalContent ?? 'unknown';
|
||||
if (offlineSettings.showPartialPlaylists) {
|
||||
return localStatus === 'all_local' || localStatus === 'some_local';
|
||||
}
|
||||
return localStatus === 'all_local';
|
||||
});
|
||||
}
|
||||
|
||||
// Apply search filter
|
||||
// Apply search filter first
|
||||
if (searchQuery.trim()) {
|
||||
const query = searchQuery.trim().toLowerCase();
|
||||
result = result.filter(p => p.name.toLowerCase().includes(query));
|
||||
}
|
||||
|
||||
// Apply visibility filter
|
||||
if (filter === 'visible') {
|
||||
result = result.filter(p => !playlistSettings.get(p.id)?.hidden);
|
||||
} else if (filter === 'hidden') {
|
||||
result = result.filter(p => playlistSettings.get(p.id)?.hidden);
|
||||
// Apply filter based on mode (offline or regular)
|
||||
if (offlineStatus.isOffline) {
|
||||
// In offline mode, use offline-specific filters
|
||||
if (filter === 'offline_all' || filter === 'all') {
|
||||
// Show all playlists with ANY local content (full or partial)
|
||||
result = result.filter(p => {
|
||||
const localStatus = playlistSettings.get(p.id)?.hasLocalContent ?? 'unknown';
|
||||
return localStatus === 'all_local' || localStatus === 'some_local';
|
||||
});
|
||||
} else if (filter === 'offline_partial') {
|
||||
// Show only playlists with partial local content
|
||||
result = result.filter(p => {
|
||||
const localStatus = playlistSettings.get(p.id)?.hasLocalContent ?? 'unknown';
|
||||
return localStatus === 'some_local';
|
||||
});
|
||||
} else if (filter === 'offline_unavailable') {
|
||||
// Show playlists with NO local content (view-only)
|
||||
result = result.filter(p => {
|
||||
const localStatus = playlistSettings.get(p.id)?.hasLocalContent ?? 'unknown';
|
||||
return localStatus === 'no' || localStatus === 'unknown';
|
||||
});
|
||||
} else if (filter === 'visible') {
|
||||
result = result.filter(p => {
|
||||
const settings = playlistSettings.get(p.id);
|
||||
const localStatus = settings?.hasLocalContent ?? 'unknown';
|
||||
return !settings?.hidden && (localStatus === 'all_local' || localStatus === 'some_local');
|
||||
});
|
||||
} else if (filter === 'hidden') {
|
||||
result = result.filter(p => playlistSettings.get(p.id)?.hidden);
|
||||
}
|
||||
} else {
|
||||
// Regular online mode filters
|
||||
if (filter === 'visible') {
|
||||
result = result.filter(p => !playlistSettings.get(p.id)?.hidden);
|
||||
} else if (filter === 'hidden') {
|
||||
result = result.filter(p => playlistSettings.get(p.id)?.hidden);
|
||||
}
|
||||
// 'all' shows everything
|
||||
}
|
||||
|
||||
// Apply sort
|
||||
@@ -321,17 +351,35 @@
|
||||
<button class="control-btn" onclick={() => { showFilterMenu = !showFilterMenu; showSortMenu = false; }}>
|
||||
{#if filter === 'hidden'}
|
||||
<EyeOff size={16} />
|
||||
{:else if filter === 'offline_unavailable'}
|
||||
<CloudOff size={16} />
|
||||
{:else}
|
||||
<Filter size={16} />
|
||||
{/if}
|
||||
<span>
|
||||
{filter === 'all' ? 'All' : filter === 'visible' ? 'Visible' : 'Hidden'}
|
||||
{#if offlineStatus.isOffline}
|
||||
{filter === 'all' || filter === 'offline_all' ? $t('offline.available') : filter === 'offline_partial' ? $t('offline.partiallyAvailable') : filter === 'offline_unavailable' ? $t('offline.notAvailableOffline') : filter === 'visible' ? 'Visible' : 'Hidden'}
|
||||
{:else}
|
||||
{filter === 'all' ? 'All' : filter === 'visible' ? 'Visible' : 'Hidden'}
|
||||
{/if}
|
||||
</span>
|
||||
</button>
|
||||
{#if showFilterMenu}
|
||||
<div class="dropdown-menu">
|
||||
<button class="dropdown-item" class:selected={filter === 'all'} onclick={() => { filter = 'all'; showFilterMenu = false; }}>
|
||||
All
|
||||
{#if offlineStatus.isOffline}
|
||||
<button class="dropdown-item" class:selected={filter === 'all' || filter === 'offline_all'} onclick={() => { filter = 'offline_all'; showFilterMenu = false; }}>
|
||||
{$t('offline.available')}
|
||||
</button>
|
||||
<button class="dropdown-item" class:selected={filter === 'offline_partial'} onclick={() => { filter = 'offline_partial'; showFilterMenu = false; }}>
|
||||
{$t('offline.partiallyAvailable')}
|
||||
</button>
|
||||
<button class="dropdown-item" class:selected={filter === 'offline_unavailable'} onclick={() => { filter = 'offline_unavailable'; showFilterMenu = false; }}>
|
||||
{$t('offline.notAvailableOffline')}
|
||||
</button>
|
||||
<div class="dropdown-divider"></div>
|
||||
{/if}
|
||||
<button class="dropdown-item" class:selected={filter === 'all' && !offlineStatus.isOffline} onclick={() => { filter = 'all'; showFilterMenu = false; }}>
|
||||
{offlineStatus.isOffline ? $t('filter.all') : 'All'}
|
||||
</button>
|
||||
<button class="dropdown-item" class:selected={filter === 'visible'} onclick={() => { filter = 'visible'; showFilterMenu = false; }}>
|
||||
Visible
|
||||
@@ -401,34 +449,42 @@
|
||||
{#each displayPlaylists as playlist (playlist.id)}
|
||||
{@const isHidden = playlistSettings.get(playlist.id)?.hidden}
|
||||
{@const localStatus = getLocalContentStatus(playlist.id)}
|
||||
{@const isUnavailable = offlineStatus.isOffline && !isPlaylistAvailableOffline(playlist.id)}
|
||||
<div
|
||||
class="grid-item"
|
||||
class:hidden={isHidden}
|
||||
class:unavailable={isUnavailable}
|
||||
class:dragging={draggedId === playlist.id}
|
||||
class:drag-over={dragOverId === playlist.id}
|
||||
draggable={sort === 'custom'}
|
||||
ondragstart={(e) => handleDragStart(e, playlist.id)}
|
||||
ondragover={(e) => handleDragOver(e, playlist.id)}
|
||||
draggable={sort === 'custom' && !isUnavailable}
|
||||
ondragstart={(e) => !isUnavailable && handleDragStart(e, playlist.id)}
|
||||
ondragover={(e) => !isUnavailable && handleDragOver(e, playlist.id)}
|
||||
ondragleave={handleDragLeave}
|
||||
ondrop={(e) => handleDrop(e, playlist.id)}
|
||||
ondrop={(e) => !isUnavailable && handleDrop(e, playlist.id)}
|
||||
ondragend={handleDragEnd}
|
||||
>
|
||||
<!-- Top row: drag handle (left) and edit button (right) -->
|
||||
<div class="grid-item-header">
|
||||
{#if sort === 'custom'}
|
||||
{#if sort === 'custom' && !isUnavailable}
|
||||
<div class="drag-handle">
|
||||
<GripVertical size={14} />
|
||||
</div>
|
||||
{:else}
|
||||
<div class="drag-handle-placeholder"></div>
|
||||
{/if}
|
||||
<button
|
||||
class="edit-btn"
|
||||
onclick={(e) => { e.stopPropagation(); openEditModal(playlist); }}
|
||||
title="Edit playlist"
|
||||
>
|
||||
<Pencil size={14} />
|
||||
</button>
|
||||
{#if !isUnavailable}
|
||||
<button
|
||||
class="edit-btn"
|
||||
onclick={(e) => { e.stopPropagation(); openEditModal(playlist); }}
|
||||
title="Edit playlist"
|
||||
>
|
||||
<Pencil size={14} />
|
||||
</button>
|
||||
{:else}
|
||||
<span class="view-only-badge" title={$t('offline.viewOnly')}>
|
||||
<CloudOff size={12} />
|
||||
</span>
|
||||
{/if}
|
||||
</div>
|
||||
|
||||
<!-- Clickable area: artwork + info -->
|
||||
@@ -437,6 +493,7 @@
|
||||
role="button"
|
||||
tabindex="0"
|
||||
onclick={() => onPlaylistSelect?.(playlist.id)}
|
||||
title={isUnavailable ? $t('offline.viewOnly') : undefined}
|
||||
>
|
||||
<div class="artwork">
|
||||
<PlaylistCollage artworks={playlist.images ?? []} size={140} />
|
||||
@@ -470,22 +527,25 @@
|
||||
{@const isHidden = playlistSettings.get(playlist.id)?.hidden}
|
||||
{@const stats = playlistStats.get(playlist.id)}
|
||||
{@const localStatus = getLocalContentStatus(playlist.id)}
|
||||
{@const isUnavailable = offlineStatus.isOffline && !isPlaylistAvailableOffline(playlist.id)}
|
||||
<div
|
||||
class="list-item"
|
||||
class:hidden={isHidden}
|
||||
class:unavailable={isUnavailable}
|
||||
class:dragging={draggedId === playlist.id}
|
||||
class:drag-over={dragOverId === playlist.id}
|
||||
draggable={sort === 'custom'}
|
||||
ondragstart={(e) => handleDragStart(e, playlist.id)}
|
||||
ondragover={(e) => handleDragOver(e, playlist.id)}
|
||||
draggable={sort === 'custom' && !isUnavailable}
|
||||
ondragstart={(e) => !isUnavailable && handleDragStart(e, playlist.id)}
|
||||
ondragover={(e) => !isUnavailable && handleDragOver(e, playlist.id)}
|
||||
ondragleave={handleDragLeave}
|
||||
ondrop={(e) => handleDrop(e, playlist.id)}
|
||||
ondrop={(e) => !isUnavailable && handleDrop(e, playlist.id)}
|
||||
ondragend={handleDragEnd}
|
||||
role="button"
|
||||
tabindex="0"
|
||||
onclick={() => onPlaylistSelect?.(playlist.id)}
|
||||
title={isUnavailable ? $t('offline.viewOnly') : undefined}
|
||||
>
|
||||
{#if sort === 'custom'}
|
||||
{#if sort === 'custom' && !isUnavailable}
|
||||
<div class="drag-handle">
|
||||
<GripVertical size={16} />
|
||||
</div>
|
||||
@@ -503,7 +563,11 @@
|
||||
{/if}
|
||||
</span>
|
||||
</div>
|
||||
{#if localStatus === 'all_local'}
|
||||
{#if isUnavailable}
|
||||
<span class="unavailable-badge" title={$t('offline.viewOnly')}>
|
||||
<CloudOff size={14} />
|
||||
</span>
|
||||
{:else if localStatus === 'all_local'}
|
||||
<span class="local-indicator all" title={$t('offline.allLocal')}>
|
||||
<Wifi size={14} />
|
||||
</span>
|
||||
@@ -523,13 +587,15 @@
|
||||
<EyeOff size={14} />
|
||||
</span>
|
||||
{/if}
|
||||
<button
|
||||
class="edit-btn"
|
||||
onclick={(e) => { e.stopPropagation(); openEditModal(playlist); }}
|
||||
title="Edit playlist"
|
||||
>
|
||||
<Pencil size={14} />
|
||||
</button>
|
||||
{#if !isUnavailable}
|
||||
<button
|
||||
class="edit-btn"
|
||||
onclick={(e) => { e.stopPropagation(); openEditModal(playlist); }}
|
||||
title="Edit playlist"
|
||||
>
|
||||
<Pencil size={14} />
|
||||
</button>
|
||||
{/if}
|
||||
</div>
|
||||
{/each}
|
||||
</div>
|
||||
@@ -677,6 +743,12 @@
|
||||
color: var(--accent-primary);
|
||||
}
|
||||
|
||||
.dropdown-divider {
|
||||
height: 1px;
|
||||
background: var(--bg-tertiary);
|
||||
margin: 4px 0;
|
||||
}
|
||||
|
||||
.playlist-count {
|
||||
font-size: 13px;
|
||||
color: var(--text-muted);
|
||||
@@ -1017,4 +1089,31 @@
|
||||
.list-item .edit-btn {
|
||||
flex-shrink: 0;
|
||||
}
|
||||
|
||||
/* Unavailable playlist styles (offline mode) */
|
||||
.grid-item.unavailable,
|
||||
.list-item.unavailable {
|
||||
opacity: 0.5;
|
||||
}
|
||||
|
||||
.grid-item.unavailable .artwork,
|
||||
.list-item.unavailable .artwork-small {
|
||||
filter: grayscale(100%);
|
||||
}
|
||||
|
||||
.view-only-badge {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
padding: 2px;
|
||||
color: var(--text-muted);
|
||||
}
|
||||
|
||||
.unavailable-badge {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
color: var(--text-muted);
|
||||
margin-right: 8px;
|
||||
flex-shrink: 0;
|
||||
}
|
||||
</style>
|
||||
@@ -446,6 +446,13 @@
|
||||
"featureDisabled": "This feature requires internet connection",
|
||||
"startWithoutLogin": "Start in offline mode without logging in",
|
||||
"noNetworkToast": "No internet connection available",
|
||||
"checkingNetwork": "Checking network connection..."
|
||||
"checkingNetwork": "Checking network connection...",
|
||||
"available": "Available Offline",
|
||||
"partiallyAvailable": "Partially Available",
|
||||
"notAvailableOffline": "Not Available Offline",
|
||||
"viewOnly": "View Only (Offline)"
|
||||
},
|
||||
"filter": {
|
||||
"all": "All"
|
||||
}
|
||||
}
|
||||
@@ -446,6 +446,13 @@
|
||||
"featureDisabled": "Esta funcion requiere conexion a internet",
|
||||
"startWithoutLogin": "Iniciar en modo offline sin autenticacion",
|
||||
"noNetworkToast": "No hay conexion a internet disponible",
|
||||
"checkingNetwork": "Verificando conexion a internet..."
|
||||
"checkingNetwork": "Verificando conexion a internet...",
|
||||
"available": "Disponible Offline",
|
||||
"partiallyAvailable": "Parcialmente Disponible",
|
||||
"notAvailableOffline": "No Disponible Offline",
|
||||
"viewOnly": "Solo Ver (Offline)"
|
||||
},
|
||||
"filter": {
|
||||
"all": "Todos"
|
||||
}
|
||||
}
|
||||
@@ -14,6 +14,7 @@ export interface QueueTrack {
|
||||
title: string;
|
||||
artist: string;
|
||||
duration: string;
|
||||
available?: boolean; // Whether track is available (false when offline without local copy)
|
||||
}
|
||||
|
||||
export interface BackendQueueTrack {
|
||||
@@ -116,6 +117,58 @@ function formatDuration(seconds: number): string {
|
||||
return `${mins}:${secs.toString().padStart(2, '0')}`;
|
||||
}
|
||||
|
||||
// ============ Offline Mode State ============
|
||||
|
||||
let isOfflineMode = false;
|
||||
let tracksWithLocalCopies = new Set<number>();
|
||||
|
||||
/**
|
||||
* Set offline mode state for queue availability checking
|
||||
*/
|
||||
export function setOfflineMode(offline: boolean): void {
|
||||
isOfflineMode = offline;
|
||||
// Refresh queue to update availability
|
||||
if (queue.length > 0) {
|
||||
syncQueueState();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Update tracks with local copies (called from offline store)
|
||||
*/
|
||||
export async function updateLocalCopiesSet(): Promise<void> {
|
||||
if (!isOfflineMode || queue.length === 0) {
|
||||
tracksWithLocalCopies = new Set();
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
const trackIds = queue.map(t => parseInt(t.id)).filter(id => !isNaN(id));
|
||||
if (trackIds.length === 0) {
|
||||
tracksWithLocalCopies = new Set();
|
||||
return;
|
||||
}
|
||||
|
||||
const localIds = await invoke<number[]>('playlist_get_tracks_with_local_copies', {
|
||||
trackIds
|
||||
});
|
||||
tracksWithLocalCopies = new Set(localIds);
|
||||
|
||||
// Update queue availability
|
||||
queue = queue.map(t => {
|
||||
const numId = parseInt(t.id);
|
||||
return {
|
||||
...t,
|
||||
available: isNaN(numId) || localTrackIds.has(numId) || tracksWithLocalCopies.has(numId)
|
||||
};
|
||||
});
|
||||
notifyListeners();
|
||||
} catch (err) {
|
||||
console.error('Failed to check local copies:', err);
|
||||
tracksWithLocalCopies = new Set();
|
||||
}
|
||||
}
|
||||
|
||||
// ============ Queue Actions ============
|
||||
|
||||
/**
|
||||
@@ -125,13 +178,31 @@ export async function syncQueueState(): Promise<void> {
|
||||
try {
|
||||
const queueState = await invoke<BackendQueueState>('get_queue_state');
|
||||
|
||||
// Get track IDs for local copy check
|
||||
const trackIds = queueState.upcoming.map(t => t.id);
|
||||
|
||||
// Check local copies if in offline mode
|
||||
let localCopies = new Set<number>();
|
||||
if (isOfflineMode && trackIds.length > 0) {
|
||||
try {
|
||||
const localIds = await invoke<number[]>('playlist_get_tracks_with_local_copies', {
|
||||
trackIds
|
||||
});
|
||||
localCopies = new Set(localIds);
|
||||
tracksWithLocalCopies = localCopies;
|
||||
} catch {
|
||||
// Ignore errors, assume all available
|
||||
}
|
||||
}
|
||||
|
||||
// Convert backend queue tracks to frontend format
|
||||
queue = queueState.upcoming.map(t => ({
|
||||
id: String(t.id),
|
||||
artwork: t.artwork_url || '',
|
||||
title: t.title,
|
||||
artist: t.artist,
|
||||
duration: formatDuration(t.duration_secs)
|
||||
duration: formatDuration(t.duration_secs),
|
||||
available: !isOfflineMode || localTrackIds.has(t.id) || localCopies.has(t.id)
|
||||
}));
|
||||
|
||||
queueTotalTracks = queueState.total_tracks;
|
||||
|
||||
+48
-2
@@ -114,6 +114,7 @@
|
||||
isLocalTrack,
|
||||
getBackendQueueState,
|
||||
getQueueState,
|
||||
setOfflineMode as setQueueOfflineMode,
|
||||
type QueueTrack,
|
||||
type BackendQueueTrack,
|
||||
type RepeatMode
|
||||
@@ -723,10 +724,53 @@
|
||||
}
|
||||
}
|
||||
|
||||
// Helper to play a track from the queue
|
||||
async function playQueueTrack(track: BackendQueueTrack) {
|
||||
// Check if a track is available for playback (handles offline mode)
|
||||
async function isTrackAvailable(track: BackendQueueTrack): Promise<boolean> {
|
||||
// Always available when online
|
||||
if (!offlineStatus.isOffline) return true;
|
||||
|
||||
// Local tracks are always available
|
||||
if (isLocalTrack(track.id)) return true;
|
||||
|
||||
// Check if Qobuz track has a local copy
|
||||
try {
|
||||
const localIds = await invoke<number[]>('playlist_get_tracks_with_local_copies', {
|
||||
trackIds: [track.id]
|
||||
});
|
||||
return localIds.includes(track.id);
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Helper to play a track from the queue (with offline skip support)
|
||||
async function playQueueTrack(track: BackendQueueTrack, skippedIds = new Set<number>()) {
|
||||
const isLocal = isLocalTrack(track.id);
|
||||
|
||||
// In offline mode, check if track is available
|
||||
if (offlineStatus.isOffline && !isLocal) {
|
||||
const available = await isTrackAvailable(track);
|
||||
if (!available) {
|
||||
// Skip to next track (prevent infinite loop)
|
||||
if (skippedIds.has(track.id)) {
|
||||
// Already tried this track, stop to prevent infinite loop
|
||||
setQueueEnded(true);
|
||||
showToast('No available tracks in queue (offline mode)', 'info');
|
||||
return;
|
||||
}
|
||||
skippedIds.add(track.id);
|
||||
|
||||
// Get next track and try to play it
|
||||
const nextTrackResult = await nextTrack();
|
||||
if (nextTrackResult) {
|
||||
await playQueueTrack(nextTrackResult, skippedIds);
|
||||
} else {
|
||||
setQueueEnded(true);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Reset queue ended flag when playing a new track
|
||||
setQueueEnded(false);
|
||||
|
||||
@@ -1559,6 +1603,8 @@
|
||||
// Subscribe to offline state changes
|
||||
const unsubscribeOffline = subscribeOffline(() => {
|
||||
offlineStatus = getOfflineStatus();
|
||||
// Sync offline mode to queue store for track availability
|
||||
setQueueOfflineMode(offlineStatus.isOffline);
|
||||
});
|
||||
|
||||
// Subscribe to navigation state changes
|
||||
|
||||
Reference in new issue
Block a user