feat: v1.18.0 — Offline Mode (Beta), MPRIS Seek, 2 New Themes, Perf Fixes

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-07-22 14:35:41 +00:00 · 2026-03-27 17:17:09 +01:00
parent b67c198227
commit 936e548f40
27 changed files with 1650 additions and 360 deletions
@@ -4,6 +4,7 @@ import { getAlbum, getArtist, getArtistInfo, setRating, buildCoverArtUrl, coverA
 import { usePlayerStore } from '../store/playerStore';
 import { useAuthStore } from '../store/authStore';
 import { useDownloadModalStore } from '../store/downloadModalStore';
+import { useOfflineStore } from '../store/offlineStore';
 import { writeFile } from '@tauri-apps/plugin-fs';
 import { join } from '@tauri-apps/api/path';
 import AlbumCard from '../components/AlbumCard';
@@ -44,6 +45,29 @@ export default function AlbumDetail() {
  const [starredSongs, setStarredSongs] = useState<Set<string>>(new Set());
  const [hoveredSongId, setHoveredSongId] = useState<string | null>(null);

+  const { downloadAlbum, deleteAlbum } = useOfflineStore();
+  const offlineTracks = useOfflineStore(s => s.tracks);
+  const offlineAlbums = useOfflineStore(s => s.albums);
+  const offlineJobs = useOfflineStore(s => s.jobs);
+  const serverId = auth.activeServerId ?? '';
+
+  const offlineStatus: 'none' | 'downloading' | 'cached' = (() => {
+    if (!album) return 'none';
+    const meta = offlineAlbums[`${serverId}:${album.album.id}`];
+    const isDownloaded = meta && meta.trackIds.length > 0 && meta.trackIds.every(tid => !!offlineTracks[`${serverId}:${tid}`]);
+    if (isDownloaded) return 'cached';
+    const isDownloading = offlineJobs.some(j => j.albumId === album.album.id && (j.status === 'queued' || j.status === 'downloading'));
+    return isDownloading ? 'downloading' : 'none';
+  })();
+
+  const offlineProgress = (() => {
+    if (!album) return null;
+    const albumJobs = offlineJobs.filter(j => j.albumId === album.album.id);
+    if (albumJobs.length === 0) return null;
+    const done = albumJobs.filter(j => j.status === 'done' || j.status === 'error').length;
+    return { done, total: albumJobs.length };
+  })();
+
  useEffect(() => {
    if (!id) return;
    setLoading(true);
@@ -183,6 +207,16 @@ export default function AlbumDetail() {
    }
  };

+  const handleCacheOffline = () => {
+    if (!album) return;
+    downloadAlbum(album.album.id, album.album.name, album.album.artist, album.album.coverArt, album.album.year, album.songs, serverId);
+  };
+
+  const handleRemoveOffline = () => {
+    if (!album) return;
+    deleteAlbum(album.album.id, serverId);
+  };
+
  // Hooks must be called unconditionally — derive from nullable album state
  const coverUrl = album?.album.coverArt ? buildCoverArtUrl(album.album.coverArt, 400) : '';
  const coverKey = album?.album.coverArt ? coverArtCacheKey(album.album.coverArt, 400) : '';
@@ -212,6 +246,10 @@ export default function AlbumDetail() {
        onEnqueueAll={handleEnqueueAll}
        onBio={handleBio}
        onCloseBio={() => setBioOpen(false)}
+        offlineStatus={offlineStatus}
+        offlineProgress={offlineProgress}
+        onCacheOffline={handleCacheOffline}
+        onRemoveOffline={handleRemoveOffline}
      />

      <AlbumTrackList
@@ -0,0 +1,115 @@
+import React from 'react';
+import { Play, HardDriveDownload, Trash2 } from 'lucide-react';
+import { useTranslation } from 'react-i18next';
+import { useOfflineStore } from '../store/offlineStore';
+import { useAuthStore } from '../store/authStore';
+import { usePlayerStore } from '../store/playerStore';
+import { buildCoverArtUrl, coverArtCacheKey } from '../api/subsonic';
+import CachedImage from '../components/CachedImage';
+
+export default function OfflineLibrary() {
+  const { t } = useTranslation();
+  const serverId = useAuthStore(s => s.activeServerId ?? '');
+  const offlineAlbums = useOfflineStore(s => s.albums);
+  const offlineTracks = useOfflineStore(s => s.tracks);
+  const deleteAlbum = useOfflineStore(s => s.deleteAlbum);
+  const playTrack = usePlayerStore(s => s.playTrack);
+  const enqueue = usePlayerStore(s => s.enqueue);
+
+  const albums = Object.values(offlineAlbums).filter(a => a.serverId === serverId);
+
+  const buildTracks = (albumId: string) => {
+    const meta = offlineAlbums[`${serverId}:${albumId}`];
+    if (!meta) return [];
+    return meta.trackIds.flatMap(tid => {
+      const t = offlineTracks[`${serverId}:${tid}`];
+      if (!t) return [];
+      return [{
+        id: t.id, title: t.title, artist: t.artist, album: t.album,
+        albumId: t.albumId, artistId: t.artistId, duration: t.duration,
+        coverArt: t.coverArt, track: undefined, year: t.year,
+        bitRate: t.bitRate, suffix: t.suffix, genre: t.genre,
+      }];
+    });
+  };
+
+  const handlePlay = (albumId: string) => {
+    const tracks = buildTracks(albumId);
+    if (tracks[0]) playTrack(tracks[0], tracks);
+  };
+
+  const handleEnqueue = (albumId: string) => {
+    enqueue(buildTracks(albumId));
+  };
+
+  return (
+    <div className="offline-library animate-fade-in">
+      <div className="offline-library-header">
+        <HardDriveDownload size={24} />
+        <div>
+          <h1 className="offline-library-title">{t('connection.offlineLibraryTitle')}</h1>
+          <p className="offline-library-count">
+            {t('connection.offlineAlbumCount', { n: albums.length, count: albums.length })}
+          </p>
+        </div>
+      </div>
+
+      {albums.length === 0 ? (
+        <div className="empty-state">{t('connection.offlineLibraryEmpty')}</div>
+      ) : (
+        <div className="album-grid-wrap">
+          {albums.map(album => {
+            const coverUrl = album.coverArt ? buildCoverArtUrl(album.coverArt, 300) : '';
+            const cacheKey = album.coverArt ? coverArtCacheKey(album.coverArt, 300) : '';
+            const trackCount = album.trackIds.filter(tid => !!offlineTracks[`${serverId}:${tid}`]).length;
+            return (
+              <div key={album.id} className="album-card card offline-library-card">
+                <div className="album-card-cover">
+                  {coverUrl ? (
+                    <CachedImage src={coverUrl} cacheKey={cacheKey} alt={`${album.name} Cover`} loading="lazy" />
+                  ) : (
+                    <div className="album-card-cover-placeholder">
+                      <HardDriveDownload size={32} />
+                    </div>
+                  )}
+                  <div className="album-card-play-overlay">
+                    <button
+                      className="album-card-details-btn"
+                      onClick={() => handlePlay(album.id)}
+                      aria-label={`${album.name} abspielen`}
+                    >
+                      <Play size={15} fill="currentColor" />
+                    </button>
+                  </div>
+                </div>
+                <div className="album-card-info">
+                  <p className="album-card-title truncate">{album.name}</p>
+                  <p className="album-card-artist truncate">{album.artist}</p>
+                  {album.year && <p className="album-card-year">{album.year}</p>}
+                  <div className="offline-library-card-meta">
+                    <button
+                      className="offline-library-enqueue"
+                      onClick={() => handleEnqueue(album.id)}
+                      title="Zur Warteschlange hinzufügen"
+                    >
+                      + Queue
+                    </button>
+                    <span className="offline-library-tracks">{trackCount} tracks</span>
+                    <button
+                      className="offline-library-delete"
+                      onClick={() => deleteAlbum(album.id, serverId)}
+                      data-tooltip={t('albumDetail.removeOffline')}
+                      data-tooltip-pos="top"
+                    >
+                      <Trash2 size={11} />
+                    </button>
+                  </div>
+                </div>
+              </div>
+            );
+          })}
+        </div>
+      )}
+    </div>
+  );
+}
@@ -6,7 +6,10 @@ import {
  Wifi, WifiOff, Globe, Music2, Sliders, LogOut, CheckCircle2, FolderOpen,
  Palette, Server, Plus, Trash2, Eye, EyeOff, Info, ExternalLink, Shuffle, X, Play, Type, Keyboard
 } from 'lucide-react';
+import { invoke } from '@tauri-apps/api/core';
 import { open as openUrl } from '@tauri-apps/plugin-shell';
+import { getImageCacheSize, clearImageCache } from '../utils/imageCache';
+import { useOfflineStore } from '../store/offlineStore';
 import { lastfmGetToken, lastfmAuthUrl, lastfmGetSession, lastfmGetUserInfo, LastfmUserInfo } from '../api/lastfm';
 import LastfmIcon from '../components/LastfmIcon';
 import CustomSelect from '../components/CustomSelect';
@@ -83,12 +86,20 @@ function AddServerForm({ onSave, onCancel }: { onSave: (data: Omit<ServerProfile
  );
 }

+function formatBytes(bytes: number): string {
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+  return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+
 export default function Settings() {
  const auth = useAuthStore();
  const theme = useThemeStore();
  const fontStore = useFontStore();
  const kb = useKeybindingsStore();
  const gs = useGlobalShortcutsStore();
+  const serverId = auth.activeServerId ?? '';
+  const clearAllOffline = useOfflineStore(s => s.clearAll);
  const [listeningFor, setListeningFor] = useState<KeyAction | null>(null);
  const [listeningForGlobal, setListeningForGlobal] = useState<GlobalAction | null>(null);
  const navigate = useNavigate();
@@ -103,12 +114,36 @@ export default function Settings() {
  const [lfmPendingToken, setLfmPendingToken] = useState<string | null>(null);
  const [lfmError, setLfmError] = useState<string | null>(null);
  const [lfmUserInfo, setLfmUserInfo] = useState<LastfmUserInfo | null>(null);
+  const [imageCacheBytes, setImageCacheBytes] = useState<number | null>(null);
+  const [offlineCacheBytes, setOfflineCacheBytes] = useState<number | null>(null);
+  const [showClearConfirm, setShowClearConfirm] = useState(false);
+  const [clearing, setClearing] = useState(false);

  useEffect(() => {
    if (!auth.lastfmSessionKey || !auth.lastfmUsername) { setLfmUserInfo(null); return; }
    lastfmGetUserInfo(auth.lastfmUsername, auth.lastfmSessionKey).then(setLfmUserInfo).catch(() => {});
  }, [auth.lastfmSessionKey, auth.lastfmUsername]);

+  useEffect(() => {
+    if (activeTab !== 'library') return;
+    getImageCacheSize().then(setImageCacheBytes);
+    invoke<number>('get_offline_cache_size').then(setOfflineCacheBytes).catch(() => setOfflineCacheBytes(0));
+  }, [activeTab]);
+
+  const handleClearCache = useCallback(async () => {
+    setClearing(true);
+    await clearImageCache();
+    await clearAllOffline(serverId);
+    const [imgBytes, offBytes] = await Promise.all([
+      getImageCacheSize(),
+      invoke<number>('get_offline_cache_size').catch(() => 0),
+    ]);
+    setImageCacheBytes(imgBytes);
+    setOfflineCacheBytes(offBytes);
+    setShowClearConfirm(false);
+    setClearing(false);
+  }, [clearAllOffline, serverId]);
+
  const startLastfmConnect = useCallback(async () => {
    setLfmError(null);
    let token: string;
@@ -363,15 +398,24 @@ export default function Settings() {
              <h2>{t('settings.behavior')}</h2>
            </div>
            <div className="settings-card">
-              <div className="settings-toggle-row">
-                <div>
-                  <div style={{ fontWeight: 500 }}>{t('settings.cacheTitle')}</div>
-                  <div style={{ fontSize: 12, color: 'var(--text-muted)' }}>{t('settings.cacheDesc')} ({auth.maxCacheMb} MB)</div>
-                </div>
+              <div style={{ fontWeight: 500, marginBottom: 4 }}>{t('settings.cacheTitle')}</div>
+              <div style={{ fontSize: 12, color: 'var(--text-muted)', marginBottom: 10, lineHeight: 1.5 }}>
+                {t('settings.cacheDesc')}
+                {(imageCacheBytes !== null || offlineCacheBytes !== null) && (
+                  <span style={{ marginLeft: 6, color: 'var(--text-secondary)' }}>
+                    — {t('settings.cacheUsed', {
+                      images: imageCacheBytes !== null ? formatBytes(imageCacheBytes) : '…',
+                      offline: offlineCacheBytes !== null ? formatBytes(offlineCacheBytes) : '…',
+                    })}
+                  </span>
+                )}
+              </div>
+              <div className="settings-toggle-row" style={{ marginBottom: 12 }}>
+                <span style={{ fontSize: 13, color: 'var(--text-secondary)' }}>{auth.maxCacheMb} MB</span>
                <input
                  type="range"
                  min={100}
-                  max={2000}
+                  max={5000}
                  step={100}
                  value={auth.maxCacheMb}
                  onChange={e => auth.setMaxCacheMb(Number(e.target.value))}
@@ -379,6 +423,28 @@ export default function Settings() {
                  id="cache-size-slider"
                />
              </div>
+              {showClearConfirm ? (
+                <div style={{ background: 'color-mix(in srgb, var(--color-danger, #e53935) 10%, transparent)', borderRadius: 'var(--radius-sm)', padding: '10px 14px', fontSize: 13, lineHeight: 1.5 }}>
+                  <div style={{ marginBottom: 8, color: 'var(--text-primary)' }}>{t('settings.cacheClearWarning')}</div>
+                  <div style={{ display: 'flex', gap: 8 }}>
+                    <button
+                      className="btn btn-primary"
+                      style={{ background: 'var(--color-danger, #e53935)', fontSize: 13 }}
+                      onClick={handleClearCache}
+                      disabled={clearing}
+                    >
+                      {t('settings.cacheClearConfirm')}
+                    </button>
+                    <button className="btn btn-ghost" style={{ fontSize: 13 }} onClick={() => setShowClearConfirm(false)} disabled={clearing}>
+                      {t('settings.cacheClearCancel')}
+                    </button>
+                  </div>
+                </div>
+              ) : (
+                <button className="btn btn-ghost" style={{ fontSize: 13 }} onClick={() => setShowClearConfirm(true)}>
+                  <Trash2 size={14} /> {t('settings.cacheClearBtn')}
+                </button>
+              )}
            </div>
          </section>