Merge branch 'development' into skip-duplicates

app/src/main/java/com/cappielloantonio/tempo/database/AppDatabase.java

@@ -12,6 +12,7 @@ import com.cappielloantonio.tempo.database.converter.DateConverters;
 import com.cappielloantonio.tempo.database.dao.ChronologyDao;
 import com.cappielloantonio.tempo.database.dao.DownloadDao;
 import com.cappielloantonio.tempo.database.dao.FavoriteDao;
+import com.cappielloantonio.tempo.database.dao.LyricsDao;
 import com.cappielloantonio.tempo.database.dao.PlaylistDao;
 import com.cappielloantonio.tempo.database.dao.QueueDao;
 import com.cappielloantonio.tempo.database.dao.RecentSearchDao;
@@ -20,6 +21,7 @@ import com.cappielloantonio.tempo.database.dao.SessionMediaItemDao;
 import com.cappielloantonio.tempo.model.Chronology;
 import com.cappielloantonio.tempo.model.Download;
 import com.cappielloantonio.tempo.model.Favorite;
+import com.cappielloantonio.tempo.model.LyricsCache;
 import com.cappielloantonio.tempo.model.Queue;
 import com.cappielloantonio.tempo.model.RecentSearch;
 import com.cappielloantonio.tempo.model.Server;
@@ -28,9 +30,9 @@ import com.cappielloantonio.tempo.subsonic.models.Playlist;
 
 @UnstableApi
 @Database(
-        version = 11,
-        entities = {Queue.class, Server.class, RecentSearch.class, Download.class, Chronology.class, Favorite.class, SessionMediaItem.class, Playlist.class},
-        autoMigrations = {@AutoMigration(from = 10, to = 11)}
+        version = 12,
+        entities = {Queue.class, Server.class, RecentSearch.class, Download.class, Chronology.class, Favorite.class, SessionMediaItem.class, Playlist.class, LyricsCache.class},
+        autoMigrations = {@AutoMigration(from = 10, to = 11), @AutoMigration(from = 11, to = 12)}
 )
 @TypeConverters({DateConverters.class})
 public abstract class AppDatabase extends RoomDatabase {
@@ -62,4 +64,6 @@ public abstract class AppDatabase extends RoomDatabase {
     public abstract SessionMediaItemDao sessionMediaItemDao();
 
     public abstract PlaylistDao playlistDao();
+
+    public abstract LyricsDao lyricsDao();
 }

app/src/main/java/com/cappielloantonio/tempo/database/dao/DownloadDao.java

@@ -15,6 +15,9 @@ public interface DownloadDao {
     @Query("SELECT * FROM download WHERE download_state = 1 ORDER BY artist, album, disc_number, track ASC")
     LiveData<List<Download>> getAll();
 
+    @Query("SELECT * FROM download WHERE download_state = 1 ORDER BY artist, album, disc_number, track ASC")
+    List<Download> getAllSync();
+
     @Query("SELECT * FROM download WHERE id = :id")
     Download getOne(String id);
 
@@ -30,6 +33,9 @@ public interface DownloadDao {
     @Query("DELETE FROM download WHERE id = :id")
     void delete(String id);
 
+    @Query("DELETE FROM download WHERE id IN (:ids)")
+    void deleteByIds(List<String> ids);
+
     @Query("DELETE FROM download")
     void deleteAll();
 }

app/src/main/java/com/cappielloantonio/tempo/database/dao/LyricsDao.java

@@ -0,0 +1,24 @@
+package com.cappielloantonio.tempo.database.dao;
+
+import androidx.lifecycle.LiveData;
+import androidx.room.Dao;
+import androidx.room.Insert;
+import androidx.room.OnConflictStrategy;
+import androidx.room.Query;
+
+import com.cappielloantonio.tempo.model.LyricsCache;
+
+@Dao
+public interface LyricsDao {
+    @Query("SELECT * FROM lyrics_cache WHERE song_id = :songId")
+    LyricsCache getOne(String songId);
+
+    @Query("SELECT * FROM lyrics_cache WHERE song_id = :songId")
+    LiveData<LyricsCache> observeOne(String songId);
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    void insert(LyricsCache lyricsCache);
+
+    @Query("DELETE FROM lyrics_cache WHERE song_id = :songId")
+    void delete(String songId);
+}

app/src/main/java/com/cappielloantonio/tempo/model/LyricsCache.kt

@@ -0,0 +1,25 @@
+package com.cappielloantonio.tempo.model
+
+import androidx.annotation.Keep
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import kotlin.jvm.JvmOverloads
+
+@Keep
+@Entity(tableName = "lyrics_cache")
+data class LyricsCache @JvmOverloads constructor(
+    @PrimaryKey
+    @ColumnInfo(name = "song_id")
+    var songId: String,
+    @ColumnInfo(name = "artist")
+    var artist: String? = null,
+    @ColumnInfo(name = "title")
+    var title: String? = null,
+    @ColumnInfo(name = "lyrics")
+    var lyrics: String? = null,
+    @ColumnInfo(name = "structured_lyrics")
+    var structuredLyrics: String? = null,
+    @ColumnInfo(name = "updated_at")
+    var updatedAt: Long = System.currentTimeMillis()
+)

app/src/main/java/com/cappielloantonio/tempo/model/SessionMediaItem.kt

@@ -3,6 +3,7 @@ package com.cappielloantonio.tempo.model
 import android.net.Uri
 import android.os.Bundle
 import androidx.annotation.Keep
+import androidx.media3.common.HeartRating
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MediaItem.RequestMetadata
 import androidx.media3.common.MediaMetadata
@@ -243,6 +244,13 @@ class SessionMediaItem() {
                     .setAlbumTitle(album)
                     .setArtist(artist)
                     .setArtworkUri(artworkUri)
+                    .setUserRating(HeartRating(starred != null))
+                    .setSupportedCommands(
+                        listOf(
+                            Constants.CUSTOM_COMMAND_TOGGLE_HEART_ON,
+                            Constants.CUSTOM_COMMAND_TOGGLE_HEART_OFF
+                        )
+                    )
                     .setExtras(bundle)
                     .setIsBrowsable(false)
                     .setIsPlayable(true)

app/src/main/java/com/cappielloantonio/tempo/repository/ArtistRepository.java

@@ -2,10 +2,12 @@ package com.cappielloantonio.tempo.repository;
 
 import androidx.annotation.NonNull;
 import androidx.lifecycle.MutableLiveData;
+import android.util.Log;
 
 import com.cappielloantonio.tempo.App;
 import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
 import com.cappielloantonio.tempo.subsonic.models.ArtistID3;
+import com.cappielloantonio.tempo.subsonic.models.AlbumID3;
 import com.cappielloantonio.tempo.subsonic.models.ArtistInfo2;
 import com.cappielloantonio.tempo.subsonic.models.Child;
 import com.cappielloantonio.tempo.subsonic.models.IndexID3;
@@ -13,12 +15,92 @@ import com.cappielloantonio.tempo.subsonic.models.IndexID3;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import retrofit2.Call;
 import retrofit2.Callback;
 import retrofit2.Response;
 
 public class ArtistRepository {
+    private final AlbumRepository albumRepository;
+
+    public ArtistRepository() {
+        this.albumRepository = new AlbumRepository();
+    }
+
+    public void getArtistAllSongs(String artistId, ArtistSongsCallback callback) {
+        Log.d("ArtistSync", "Getting albums for artist: " + artistId);
+
+        // Get the artist info first, which contains the albums
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getArtist(artistId)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        if (response.isSuccessful() && response.body() != null && 
+                            response.body().getSubsonicResponse().getArtist() != null && 
+                            response.body().getSubsonicResponse().getArtist().getAlbums() != null) {
+                            
+                            List<AlbumID3> albums = response.body().getSubsonicResponse().getArtist().getAlbums();
+                            Log.d("ArtistSync", "Got albums directly: " + albums.size());
+                            
+                            if (!albums.isEmpty()) {
+                                fetchAllAlbumSongsWithCallback(albums, callback);
+                            } else {
+                                Log.d("ArtistSync", "No albums found in artist response");
+                                callback.onSongsCollected(new ArrayList<>());
+                            }
+                        } else {
+                            Log.d("ArtistSync", "Failed to get artist info");
+                            callback.onSongsCollected(new ArrayList<>());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        Log.d("ArtistSync", "Error getting artist info: " + t.getMessage());
+                        callback.onSongsCollected(new ArrayList<>());
+                    }
+                });
+    }
+
+    private void fetchAllAlbumSongsWithCallback(List<AlbumID3> albums, ArtistSongsCallback callback) {
+        if (albums == null || albums.isEmpty()) {
+            Log.d("ArtistSync", "No albums to process");
+            callback.onSongsCollected(new ArrayList<>());
+            return;
+        }
+
+        List<Child> allSongs = new ArrayList<>();
+        AtomicInteger remainingAlbums = new AtomicInteger(albums.size());
+        Log.d("ArtistSync", "Processing " + albums.size() + " albums");
+        
+        for (AlbumID3 album : albums) {
+            Log.d("ArtistSync", "Getting tracks for album: " + album.getName());
+            MutableLiveData<List<Child>> albumTracks = albumRepository.getAlbumTracks(album.getId());
+            albumTracks.observeForever(songs -> {
+                Log.d("ArtistSync", "Got " + (songs != null ? songs.size() : 0) + " songs from album");
+                if (songs != null) {
+                    allSongs.addAll(songs);
+                }
+                albumTracks.removeObservers(null);
+                
+                int remaining = remainingAlbums.decrementAndGet();
+                Log.d("ArtistSync", "Remaining albums: " + remaining);
+                
+                if (remaining == 0) {
+                    Log.d("ArtistSync", "All albums processed. Total songs: " + allSongs.size());
+                    callback.onSongsCollected(allSongs);
+                }
+            });
+        }
+    }
+
+    public interface ArtistSongsCallback {
+        void onSongsCollected(List<Child> songs);
+    }
+
     public MutableLiveData<List<ArtistID3>> getStarredArtists(boolean random, int size) {
         MutableLiveData<List<ArtistID3>> starredArtists = new MutableLiveData<>(new ArrayList<>());
 
@@ -89,7 +171,7 @@ public class ArtistRepository {
     }
 
     /*
-     * Metodo che mi restituisce le informazioni essenzionali dell'artista (cover, numero di album...)
+     * Method that returns essential artist information (cover, album number, etc.)
      */
     public void getArtistInfo(List<ArtistID3> artists, MutableLiveData<List<ArtistID3>> list) {
         List<ArtistID3> liveArtists = list.getValue();

app/src/main/java/com/cappielloantonio/tempo/repository/DownloadRepository.java

@@ -18,6 +18,20 @@ public class DownloadRepository {
         return downloadDao.getAll();
     }
 
+    public List<Download> getAllDownloads() {
+        GetAllDownloadsThreadSafe getDownloads = new GetAllDownloadsThreadSafe(downloadDao);
+        Thread thread = new Thread(getDownloads);
+        thread.start();
+
+        try {
+            thread.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        return getDownloads.getDownloads();
+    }
+
     public Download getDownload(String id) {
         Download download = null;
 
@@ -35,6 +49,24 @@ public class DownloadRepository {
         return download;
     }
 
+    private static class GetAllDownloadsThreadSafe implements Runnable {
+        private final DownloadDao downloadDao;
+        private List<Download> downloads;
+
+        public GetAllDownloadsThreadSafe(DownloadDao downloadDao) {
+            this.downloadDao = downloadDao;
+        }
+
+        @Override
+        public void run() {
+            downloads = downloadDao.getAllSync();
+        }
+
+        public List<Download> getDownloads() {
+            return downloads;
+        }
+    }
+
     private static class GetDownloadThreadSafe implements Runnable {
         private final DownloadDao downloadDao;
         private final String id;
@@ -143,6 +175,12 @@ public class DownloadRepository {
         thread.start();
     }
 
+    public void delete(List<String> ids) {
+        DeleteMultipleThreadSafe delete = new DeleteMultipleThreadSafe(downloadDao, ids);
+        Thread thread = new Thread(delete);
+        thread.start();
+    }
+
     private static class DeleteThreadSafe implements Runnable {
         private final DownloadDao downloadDao;
         private final String id;
@@ -157,4 +195,19 @@ public class DownloadRepository {
             downloadDao.delete(id);
         }
     }
+
+    private static class DeleteMultipleThreadSafe implements Runnable {
+        private final DownloadDao downloadDao;
+        private final List<String> ids;
+
+        public DeleteMultipleThreadSafe(DownloadDao downloadDao, List<String> ids) {
+            this.downloadDao = downloadDao;
+            this.ids = ids;
+        }
+
+        @Override
+        public void run() {
+            downloadDao.deleteByIds(ids);
+        }
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/repository/LyricsRepository.java

@@ -0,0 +1,92 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.lifecycle.LiveData;
+
+import com.cappielloantonio.tempo.database.AppDatabase;
+import com.cappielloantonio.tempo.database.dao.LyricsDao;
+import com.cappielloantonio.tempo.model.LyricsCache;
+
+public class LyricsRepository {
+    private final LyricsDao lyricsDao = AppDatabase.getInstance().lyricsDao();
+
+    public LyricsCache getLyrics(String songId) {
+        GetLyricsThreadSafe getLyricsThreadSafe = new GetLyricsThreadSafe(lyricsDao, songId);
+        Thread thread = new Thread(getLyricsThreadSafe);
+        thread.start();
+
+        try {
+            thread.join();
+            return getLyricsThreadSafe.getLyrics();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    public LiveData<LyricsCache> observeLyrics(String songId) {
+        return lyricsDao.observeOne(songId);
+    }
+
+    public void insert(LyricsCache lyricsCache) {
+        InsertThreadSafe insert = new InsertThreadSafe(lyricsDao, lyricsCache);
+        Thread thread = new Thread(insert);
+        thread.start();
+    }
+
+    public void delete(String songId) {
+        DeleteThreadSafe delete = new DeleteThreadSafe(lyricsDao, songId);
+        Thread thread = new Thread(delete);
+        thread.start();
+    }
+
+    private static class GetLyricsThreadSafe implements Runnable {
+        private final LyricsDao lyricsDao;
+        private final String songId;
+        private LyricsCache lyricsCache;
+
+        public GetLyricsThreadSafe(LyricsDao lyricsDao, String songId) {
+            this.lyricsDao = lyricsDao;
+            this.songId = songId;
+        }
+
+        @Override
+        public void run() {
+            lyricsCache = lyricsDao.getOne(songId);
+        }
+
+        public LyricsCache getLyrics() {
+            return lyricsCache;
+        }
+    }
+
+    private static class InsertThreadSafe implements Runnable {
+        private final LyricsDao lyricsDao;
+        private final LyricsCache lyricsCache;
+
+        public InsertThreadSafe(LyricsDao lyricsDao, LyricsCache lyricsCache) {
+            this.lyricsDao = lyricsDao;
+            this.lyricsCache = lyricsCache;
+        }
+
+        @Override
+        public void run() {
+            lyricsDao.insert(lyricsCache);
+        }
+    }
+
+    private static class DeleteThreadSafe implements Runnable {
+        private final LyricsDao lyricsDao;
+        private final String songId;
+
+        public DeleteThreadSafe(LyricsDao lyricsDao, String songId) {
+            this.lyricsDao = lyricsDao;
+            this.songId = songId;
+        }
+
+        @Override
+        public void run() {
+            lyricsDao.delete(songId);
+        }
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/service/EqualizerManager.kt

@@ -0,0 +1,47 @@
+package com.cappielloantonio.tempo.service
+
+import android.media.audiofx.Equalizer
+
+class EqualizerManager {
+
+    private var equalizer: Equalizer? = null
+
+    fun attachToSession(audioSessionId: Int): Boolean {
+        release()
+        if (audioSessionId != 0 && audioSessionId != -1) {
+            try {
+                equalizer = Equalizer(0, audioSessionId).apply {
+                    enabled = true
+                }
+                return true
+            } catch (e: Exception) {
+                // Some devices may not support Equalizer or audio session may be invalid
+                equalizer = null
+            }
+        }
+        return false
+    }
+
+    fun setBandLevel(band: Short, level: Short) {
+        equalizer?.setBandLevel(band, level)
+    }
+
+    fun getNumberOfBands(): Short = equalizer?.numberOfBands ?: 0
+
+    fun getBandLevelRange(): ShortArray? = equalizer?.bandLevelRange
+
+    fun getCenterFreq(band: Short): Int? =
+        equalizer?.getCenterFreq(band)?.div(1000)
+
+    fun getBandLevel(band: Short): Short? =
+        equalizer?.getBandLevel(band)
+
+    fun setEnabled(enabled: Boolean) {
+        equalizer?.enabled = enabled
+    }
+
+    fun release() {
+        equalizer?.release()
+        equalizer = null
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/service/MediaManager.java

@@ -1,11 +1,17 @@
 package com.cappielloantonio.tempo.service;
 
 import android.content.ComponentName;
+import android.util.Log;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.annotation.OptIn;
+import androidx.lifecycle.LifecycleOwner;
 import androidx.lifecycle.LiveData;
 import androidx.lifecycle.Observer;
 import androidx.media3.common.MediaItem;
+import androidx.media3.common.Player;
+import androidx.media3.common.Timeline;
 import androidx.media3.common.util.UnstableApi;
 import androidx.media3.session.MediaBrowser;
 import androidx.media3.session.SessionToken;
@@ -21,14 +27,79 @@ import com.cappielloantonio.tempo.subsonic.models.InternetRadioStation;
 import com.cappielloantonio.tempo.subsonic.models.PodcastEpisode;
 import com.cappielloantonio.tempo.util.MappingUtil;
 import com.cappielloantonio.tempo.util.Preferences;
+import com.cappielloantonio.tempo.viewmodel.PlaybackViewModel;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.MoreExecutors;
 
+import java.lang.ref.WeakReference;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
 
 public class MediaManager {
     private static final String TAG = "MediaManager";
+    private static WeakReference<MediaBrowser> attachedBrowserRef = new WeakReference<>(null);
+
+    public static void registerPlaybackObserver(
+            ListenableFuture<MediaBrowser> browserFuture,
+            PlaybackViewModel playbackViewModel
+    ) {
+        if (browserFuture == null) return;
+
+        Futures.addCallback(browserFuture, new FutureCallback<MediaBrowser>() {
+            @Override
+            public void onSuccess(MediaBrowser browser) {
+                MediaBrowser current = attachedBrowserRef.get();
+                if (current != browser) {
+                    browser.addListener(new Player.Listener() {
+                        @Override
+                        public void onEvents(@NonNull Player player, @NonNull Player.Events events) {
+                            if (events.contains(Player.EVENT_MEDIA_ITEM_TRANSITION)
+                                    || events.contains(Player.EVENT_PLAY_WHEN_READY_CHANGED)
+                                    || events.contains(Player.EVENT_PLAYBACK_STATE_CHANGED)) {
+
+                                String mediaId = player.getCurrentMediaItem() != null
+                                        ? player.getCurrentMediaItem().mediaId
+                                        : null;
+
+                                boolean playing = player.getPlaybackState() == Player.STATE_READY
+                                        && player.getPlayWhenReady();
+
+                                playbackViewModel.update(mediaId, playing);
+                            }
+                        }
+                    });
+
+                    String mediaId = browser.getCurrentMediaItem() != null
+                            ? browser.getCurrentMediaItem().mediaId
+                            : null;
+                    boolean playing = browser.getPlaybackState() == Player.STATE_READY && browser.getPlayWhenReady();
+                    playbackViewModel.update(mediaId, playing);
+
+                    attachedBrowserRef = new WeakReference<>(browser);
+                } else {
+                    String mediaId = browser.getCurrentMediaItem() != null
+                            ? browser.getCurrentMediaItem().mediaId
+                            : null;
+                    boolean playing = browser.getPlaybackState() == Player.STATE_READY && browser.getPlayWhenReady();
+                    playbackViewModel.update(mediaId, playing);
+                }
+            }
+
+            @Override
+            public void onFailure(@NonNull Throwable t) {
+                Log.e(TAG, "Failed to get MediaBrowser instance", t);
+            }
+        }, MoreExecutors.directExecutor());
+    }
+
+    public static void onBrowserReleased(@Nullable MediaBrowser released) {
+        MediaBrowser attached = attachedBrowserRef.get();
+        if (attached == released) {
+            attachedBrowserRef.clear();
+        }
+    }
 
     public static void reset(ListenableFuture<MediaBrowser> mediaBrowserListenableFuture) {
         if (mediaBrowserListenableFuture != null) {
@@ -107,11 +178,24 @@ public class MediaManager {
             mediaBrowserListenableFuture.addListener(() -> {
                 try {
                     if (mediaBrowserListenableFuture.isDone()) {
-                        mediaBrowserListenableFuture.get().clearMediaItems();
-                        mediaBrowserListenableFuture.get().setMediaItems(MappingUtil.mapMediaItems(media));
-                        mediaBrowserListenableFuture.get().prepare();
-                        mediaBrowserListenableFuture.get().seekTo(startIndex, 0);
-                        mediaBrowserListenableFuture.get().play();
+                        MediaBrowser browser = mediaBrowserListenableFuture.get();
+                        browser.clearMediaItems();
+                        browser.setMediaItems(MappingUtil.mapMediaItems(media));
+                        browser.prepare();
+
+                        Player.Listener timelineListener = new Player.Listener() {
+                            @Override
+                            public void onTimelineChanged(Timeline timeline, int reason) {
+                                int itemCount = browser.getMediaItemCount();
+                                if (itemCount > 0 && startIndex >= 0 && startIndex < itemCount) {
+                                    browser.seekTo(startIndex, 0);
+                                    browser.play();
+                                    browser.removeListener(this);
+                                }
+                            }
+                        };
+                        browser.addListener(timelineListener);
+
                         enqueueDatabase(media, true, 0);
                     }
                 } catch (ExecutionException | InterruptedException e) {
@@ -139,6 +223,25 @@ public class MediaManager {
         }
     }
 
+    public static void playDownloadedMediaItem(ListenableFuture<MediaBrowser> mediaBrowserListenableFuture, MediaItem mediaItem) {
+        if (mediaBrowserListenableFuture != null && mediaItem != null) {
+            mediaBrowserListenableFuture.addListener(() -> {
+                try {
+                    if (mediaBrowserListenableFuture.isDone()) {
+                        MediaBrowser mediaBrowser = mediaBrowserListenableFuture.get();
+                        mediaBrowser.clearMediaItems();
+                        mediaBrowser.setMediaItem(mediaItem);
+                        mediaBrowser.prepare();
+                        mediaBrowser.play();
+                        clearDatabase();
+                    }
+                } catch (ExecutionException | InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }, MoreExecutors.directExecutor());
+        }
+    }
+
     public static void startRadio(ListenableFuture<MediaBrowser> mediaBrowserListenableFuture, InternetRadioStation internetRadioStation) {
         if (mediaBrowserListenableFuture != null) {
             mediaBrowserListenableFuture.addListener(() -> {

app/src/main/java/com/cappielloantonio/tempo/subsonic/api/system/SystemClient.java

@@ -5,6 +5,9 @@ import android.util.Log;
 import com.cappielloantonio.tempo.subsonic.RetrofitClient;
 import com.cappielloantonio.tempo.subsonic.Subsonic;
 import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+import com.cappielloantonio.tempo.util.Preferences;
+
+import java.util.concurrent.TimeUnit;
 
 import retrofit2.Call;
 
@@ -21,7 +24,15 @@ public class SystemClient {
 
     public Call<ApiResponse> ping() {
         Log.d(TAG, "ping()");
-        return systemService.ping(subsonic.getParams());
+        Call<ApiResponse> pingCall = systemService.ping(subsonic.getParams());
+        if (Preferences.isInUseServerAddressLocal()) {
+            pingCall.timeout()
+                    .timeout(1, TimeUnit.SECONDS);
+        } else {
+            pingCall.timeout()
+                    .timeout(3, TimeUnit.SECONDS);
+        }
+        return pingCall;
     }
 
     public Call<ApiResponse> getLicense() {

app/src/main/java/com/cappielloantonio/tempo/ui/activity/MainActivity.java

@@ -1,11 +1,14 @@
 package com.cappielloantonio.tempo.ui.activity;
 
 import android.content.Context;
+import android.content.Intent;
 import android.content.IntentFilter;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
+import android.net.Uri;
 import android.os.Bundle;
 import android.os.Handler;
+import android.text.TextUtils;
 import android.util.Log;
 import android.view.View;
 
@@ -13,7 +16,10 @@ import androidx.annotation.NonNull;
 import androidx.core.splashscreen.SplashScreen;
 import androidx.fragment.app.FragmentManager;
 import androidx.lifecycle.ViewModelProvider;
+import androidx.media3.common.MediaItem;
+import androidx.media3.common.MediaMetadata;
 import androidx.media3.common.Player;
+import androidx.media3.common.MimeTypes;
 import androidx.media3.common.util.UnstableApi;
 import androidx.navigation.NavController;
 import androidx.navigation.fragment.NavHostFragment;
@@ -56,6 +62,7 @@ public class MainActivity extends BaseActivity {
     private BottomSheetBehavior bottomSheetBehavior;
 
     ConnectivityStatusBroadcastReceiver connectivityStatusBroadcastReceiver;
+    private Intent pendingDownloadPlaybackIntent;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
@@ -77,12 +84,16 @@ public class MainActivity extends BaseActivity {
         checkConnectionType();
         getOpenSubsonicExtensions();
         checkTempoUpdate();
+
+        maybeSchedulePlaybackIntent(getIntent());
     }
 
     @Override
     protected void onStart() {
         super.onStart();
+        pingServer();
         initService();
+        consumePendingPlaybackIntent();
     }
 
     @Override
@@ -98,6 +109,14 @@ public class MainActivity extends BaseActivity {
         bind = null;
     }
 
+    @Override
+    protected void onNewIntent(Intent intent) {
+        super.onNewIntent(intent);
+        setIntent(intent);
+        maybeSchedulePlaybackIntent(intent);
+        consumePendingPlaybackIntent();
+    }
+
     @Override
     public void onBackPressed() {
         if (bottomSheetBehavior.getState() == BottomSheetBehavior.STATE_EXPANDED)
@@ -351,6 +370,7 @@ public class MainActivity extends BaseActivity {
                     Preferences.switchInUseServerAddress();
                     App.refreshSubsonicClient();
                     pingServer();
+                    resetView();
                 } else {
                     Preferences.setOpenSubsonic(subsonicResponse.getOpenSubsonic() != null && subsonicResponse.getOpenSubsonic());
                 }
@@ -361,6 +381,7 @@ public class MainActivity extends BaseActivity {
                 Preferences.switchInUseServerAddress();
                 App.refreshSubsonicClient();
                 pingServer();
+                resetView();
             } else {
                 mainViewModel.ping().observe(this, subsonicResponse -> {
                     if (subsonicResponse == null) {
@@ -376,6 +397,13 @@ public class MainActivity extends BaseActivity {
         }
     }
 
+    private void resetView() {
+        resetViewModel();
+        int id = Objects.requireNonNull(navController.getCurrentDestination()).getId();
+        navController.popBackStack(id, true);
+        navController.navigate(id);
+    }
+
     private void getOpenSubsonicExtensions() {
         if (Preferences.getToken() != null) {
             mainViewModel.getOpenSubsonicExtensions().observe(this, openSubsonicExtensions -> {
@@ -408,4 +436,68 @@ public class MainActivity extends BaseActivity {
             }
         }
     }
+
+    private void maybeSchedulePlaybackIntent(Intent intent) {
+        if (intent == null) return;
+        if (Constants.ACTION_PLAY_EXTERNAL_DOWNLOAD.equals(intent.getAction())
+                || intent.hasExtra(Constants.EXTRA_DOWNLOAD_URI)) {
+            pendingDownloadPlaybackIntent = new Intent(intent);
+        }
+    }
+
+    private void consumePendingPlaybackIntent() {
+        if (pendingDownloadPlaybackIntent == null) return;
+        Intent intent = pendingDownloadPlaybackIntent;
+        pendingDownloadPlaybackIntent = null;
+        playDownloadedMedia(intent);
+    }
+
+    private void playDownloadedMedia(Intent intent) {
+        String uriString = intent.getStringExtra(Constants.EXTRA_DOWNLOAD_URI);
+        if (TextUtils.isEmpty(uriString)) {
+            return;
+        }
+
+        Uri uri = Uri.parse(uriString);
+        String mediaId = intent.getStringExtra(Constants.EXTRA_DOWNLOAD_MEDIA_ID);
+        if (TextUtils.isEmpty(mediaId)) {
+            mediaId = uri.toString();
+        }
+
+        String title = intent.getStringExtra(Constants.EXTRA_DOWNLOAD_TITLE);
+        String artist = intent.getStringExtra(Constants.EXTRA_DOWNLOAD_ARTIST);
+        String album = intent.getStringExtra(Constants.EXTRA_DOWNLOAD_ALBUM);
+        int duration = intent.getIntExtra(Constants.EXTRA_DOWNLOAD_DURATION, 0);
+
+        Bundle extras = new Bundle();
+        extras.putString("id", mediaId);
+        extras.putString("title", title);
+        extras.putString("artist", artist);
+        extras.putString("album", album);
+        extras.putString("uri", uri.toString());
+        extras.putString("type", Constants.MEDIA_TYPE_MUSIC);
+        extras.putInt("duration", duration);
+
+        MediaMetadata.Builder metadataBuilder = new MediaMetadata.Builder()
+                .setExtras(extras)
+                .setIsBrowsable(false)
+                .setIsPlayable(true);
+
+        if (!TextUtils.isEmpty(title)) metadataBuilder.setTitle(title);
+        if (!TextUtils.isEmpty(artist)) metadataBuilder.setArtist(artist);
+        if (!TextUtils.isEmpty(album)) metadataBuilder.setAlbumTitle(album);
+
+        MediaItem mediaItem = new MediaItem.Builder()
+                .setMediaId(mediaId)
+                .setMediaMetadata(metadataBuilder.build())
+                .setUri(uri)
+                .setMimeType(MimeTypes.BASE_TYPE_AUDIO)
+                .setRequestMetadata(new MediaItem.RequestMetadata.Builder()
+                        .setMediaUri(uri)
+                        .setExtras(extras)
+                        .build())
+                .build();
+
+        MediaManager.playDownloadedMediaItem(getMediaBrowserListenableFuture(), mediaItem);
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/ui/adapter/PlayerSongQueueAdapter.java

@@ -2,6 +2,7 @@ package com.cappielloantonio.tempo.ui.adapter;
 
 import android.graphics.drawable.Drawable;
 import android.os.Bundle;
+import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
@@ -23,17 +24,24 @@ import com.cappielloantonio.tempo.util.Constants;
 import com.cappielloantonio.tempo.util.MusicUtil;
 import com.cappielloantonio.tempo.util.Preferences;
 import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 
 public class PlayerSongQueueAdapter extends RecyclerView.Adapter<PlayerSongQueueAdapter.ViewHolder> {
+    private static final String TAG = "PlayerSongQueueAdapter";
     private final ClickCallback click;
 
     private ListenableFuture<MediaBrowser> mediaBrowserListenableFuture;
     private List<Child> songs;
 
+    private String currentPlayingId;
+    private boolean isPlaying;
+    private List<Integer> currentPlayingPositions = Collections.emptyList();
+
     public PlayerSongQueueAdapter(ClickCallback click) {
         this.click = click;
         this.songs = Collections.emptyList();
@@ -104,6 +112,46 @@ public class PlayerSongQueueAdapter extends RecyclerView.Adapter<PlayerSongQueue
         } else {
             holder.item.ratingIndicatorImageView.setVisibility(View.GONE);
         }
+        holder.itemView.setOnClickListener(v -> {
+            mediaBrowserListenableFuture.addListener(() -> {
+                try {
+                    MediaBrowser mediaBrowser = mediaBrowserListenableFuture.get();
+                    int pos = holder.getBindingAdapterPosition();
+                    Child s = songs.get(pos);
+                    if (currentPlayingId != null && currentPlayingId.equals(s.getId())) {
+                        if (isPlaying) {
+                            mediaBrowser.pause();
+                        } else {
+                            mediaBrowser.play();
+                        }
+                    } else {
+                        mediaBrowser.seekTo(pos, 0);
+                        mediaBrowser.play();
+                    }
+                } catch (Exception e) {
+                    Log.w(TAG, "Error obtaining MediaBrowser", e);
+                }
+            }, MoreExecutors.directExecutor());
+
+        });
+        bindPlaybackState(holder, song);
+    }
+
+    private void bindPlaybackState(@NonNull PlayerSongQueueAdapter.ViewHolder holder, @NonNull Child song) {
+        boolean isCurrent = currentPlayingId != null && currentPlayingId.equals(song.getId());
+
+        if (isCurrent) {
+            holder.item.playPauseIcon.setVisibility(View.VISIBLE);
+            if (isPlaying) {
+                holder.item.playPauseIcon.setImageResource(R.drawable.ic_pause);
+            } else {
+                holder.item.playPauseIcon.setImageResource(R.drawable.ic_play);
+            }
+            holder.item.coverArtOverlay.setVisibility(View.VISIBLE);
+        } else {
+            holder.item.playPauseIcon.setVisibility(View.INVISIBLE);
+            holder.item.coverArtOverlay.setVisibility(View.INVISIBLE);
+        }
     }
 
     public List<Child> getItems() {
@@ -132,6 +180,46 @@ public class PlayerSongQueueAdapter extends RecyclerView.Adapter<PlayerSongQueue
         this.mediaBrowserListenableFuture = mediaBrowserListenableFuture;
     }
 
+    public void setPlaybackState(String mediaId, boolean playing) {
+        String oldId = this.currentPlayingId;
+        boolean oldPlaying = this.isPlaying;
+        List<Integer> oldPositions = currentPlayingPositions;
+
+        this.currentPlayingId = mediaId;
+        this.isPlaying = playing;
+
+        if (Objects.equals(oldId, mediaId) && oldPlaying == playing) {
+            List<Integer> newPositionsCheck = mediaId != null ? findPositionsById(mediaId) : Collections.emptyList();
+            if (oldPositions.equals(newPositionsCheck)) {
+                return;
+            }
+        }
+
+        currentPlayingPositions = mediaId != null ? findPositionsById(mediaId) : Collections.emptyList();
+
+        for (int pos : oldPositions) {
+            if (pos >= 0 && pos < songs.size()) {
+                notifyItemChanged(pos, "payload_playback");
+            }
+        }
+        for (int pos : currentPlayingPositions) {
+            if (!oldPositions.contains(pos) && pos >= 0 && pos < songs.size()) {
+                notifyItemChanged(pos, "payload_playback");
+            }
+        }
+    }
+
+    private List<Integer> findPositionsById(String id) {
+        if (id == null) return Collections.emptyList();
+        List<Integer> positions = new ArrayList<>();
+        for (int i = 0; i < songs.size(); i++) {
+            if (id.equals(songs.get(i).getId())) {
+                positions.add(i);
+            }
+        }
+        return positions;
+    }
+
     public Child getItem(int id) {
         return songs.get(id);
     }

app/src/main/java/com/cappielloantonio/tempo/ui/adapter/SongHorizontalAdapter.java

@@ -1,6 +1,8 @@
 package com.cappielloantonio.tempo.ui.adapter;
 
+import android.app.Activity;
 import android.os.Bundle;
+import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
@@ -9,7 +11,9 @@ import android.widget.Filterable;
 
 import androidx.annotation.NonNull;
 import androidx.appcompat.content.res.AppCompatResources;
+import androidx.lifecycle.LifecycleOwner;
 import androidx.media3.common.util.UnstableApi;
+import androidx.media3.session.MediaBrowser;
 import androidx.recyclerview.widget.RecyclerView;
 
 import com.cappielloantonio.tempo.R;
@@ -21,8 +25,11 @@ import com.cappielloantonio.tempo.subsonic.models.Child;
 import com.cappielloantonio.tempo.subsonic.models.DiscTitle;
 import com.cappielloantonio.tempo.util.Constants;
 import com.cappielloantonio.tempo.util.DownloadUtil;
+import com.cappielloantonio.tempo.util.ExternalAudioReader;
+import com.cappielloantonio.tempo.util.MappingUtil;
 import com.cappielloantonio.tempo.util.MusicUtil;
 import com.cappielloantonio.tempo.util.Preferences;
+import com.google.common.util.concurrent.ListenableFuture;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -30,6 +37,7 @@ import java.util.Comparator;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.concurrent.ExecutionException;
 
 @UnstableApi
 public class SongHorizontalAdapter extends RecyclerView.Adapter<SongHorizontalAdapter.ViewHolder> implements Filterable {
@@ -42,6 +50,11 @@ public class SongHorizontalAdapter extends RecyclerView.Adapter<SongHorizontalAd
     private List<Child> songs;
     private String currentFilter;
 
+    private String currentPlayingId;
+    private boolean isPlaying;
+    private List<Integer> currentPlayingPositions = Collections.emptyList();
+    private ListenableFuture<MediaBrowser> mediaBrowserListenableFuture;
+
     private final Filter filtering = new Filter() {
         @Override
         protected FilterResults performFiltering(CharSequence constraint) {
@@ -70,10 +83,16 @@ public class SongHorizontalAdapter extends RecyclerView.Adapter<SongHorizontalAd
         protected void publishResults(CharSequence constraint, FilterResults results) {
             songs = (List<Child>) results.values;
             notifyDataSetChanged();
+
+            for (int pos : currentPlayingPositions) {
+                if (pos >= 0 && pos < songs.size()) {
+                    notifyItemChanged(pos, "payload_playback");
+                }
+            }
         }
     };
 
-    public SongHorizontalAdapter(ClickCallback click, boolean showCoverArt, boolean showAlbum, AlbumID3 album) {
+    public SongHorizontalAdapter(LifecycleOwner lifecycleOwner, ClickCallback click, boolean showCoverArt, boolean showAlbum, AlbumID3 album) {
         this.click = click;
         this.showCoverArt = showCoverArt;
         this.showAlbum = showAlbum;
@@ -81,6 +100,11 @@ public class SongHorizontalAdapter extends RecyclerView.Adapter<SongHorizontalAd
         this.songsFull = Collections.emptyList();
         this.currentFilter = "";
         this.album = album;
+        setHasStableIds(false);
+
+        if (lifecycleOwner != null) {
+            MappingUtil.observeExternalAudioRefresh(lifecycleOwner, this::handleExternalAudioRefresh);
+        }
     }
 
     @NonNull
@@ -91,7 +115,16 @@ public class SongHorizontalAdapter extends RecyclerView.Adapter<SongHorizontalAd
     }
 
     @Override
-    public void onBindViewHolder(ViewHolder holder, int position) {
+    public void onBindViewHolder(@NonNull ViewHolder holder, int position, @NonNull List<Object> payloads) {
+        if (!payloads.isEmpty() && payloads.contains("payload_playback")) {
+            bindPlaybackState(holder, songs.get(position));
+        } else {
+            super.onBindViewHolder(holder, position, payloads);
+        }
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
         Child song = songs.get(position);
 
         holder.item.searchResultSongTitleTextView.setText(song.getTitle());
@@ -109,10 +142,18 @@ public class SongHorizontalAdapter extends RecyclerView.Adapter<SongHorizontalAd
 
         holder.item.trackNumberTextView.setText(MusicUtil.getReadableTrackNumber(holder.itemView.getContext(), song.getTrack()));
 
-        if (DownloadUtil.getDownloadTracker(holder.itemView.getContext()).isDownloaded(song.getId())) {
-            holder.item.searchResultDownloadIndicatorImageView.setVisibility(View.VISIBLE);
+        if (Preferences.getDownloadDirectoryUri() == null) {
+            if (DownloadUtil.getDownloadTracker(holder.itemView.getContext()).isDownloaded(song.getId())) {
+                holder.item.searchResultDownloadIndicatorImageView.setVisibility(View.VISIBLE);
+            } else {
+                holder.item.searchResultDownloadIndicatorImageView.setVisibility(View.GONE);
+            }
         } else {
-            holder.item.searchResultDownloadIndicatorImageView.setVisibility(View.GONE);
+            if (ExternalAudioReader.getUri(song) != null) {
+                holder.item.searchResultDownloadIndicatorImageView.setVisibility(View.VISIBLE);
+            } else {
+                holder.item.searchResultDownloadIndicatorImageView.setVisibility(View.GONE);
+            }
         }
 
         if (showCoverArt) CustomGlideRequest.Builder
@@ -165,6 +206,39 @@ public class SongHorizontalAdapter extends RecyclerView.Adapter<SongHorizontalAd
         } else {
             holder.item.ratingIndicatorImageView.setVisibility(View.GONE);
         }
+
+        bindPlaybackState(holder, song);
+    }
+
+    private void handleExternalAudioRefresh() {
+        if (Preferences.getDownloadDirectoryUri() != null) {
+            notifyDataSetChanged();
+        }
+    }
+
+    private void bindPlaybackState(@NonNull ViewHolder holder, @NonNull Child song) {
+        boolean isCurrent = currentPlayingId != null && currentPlayingId.equals(song.getId());
+
+        if (isCurrent) {
+            holder.item.playPauseIcon.setVisibility(View.VISIBLE);
+            if (isPlaying) {
+                holder.item.playPauseIcon.setImageResource(R.drawable.ic_pause);
+            } else {
+                holder.item.playPauseIcon.setImageResource(R.drawable.ic_play);
+            }
+            if (!showCoverArt) {
+                holder.item.trackNumberTextView.setVisibility(View.INVISIBLE);
+            } else {
+                holder.item.coverArtOverlay.setVisibility(View.VISIBLE);
+            }
+        } else {
+            holder.item.playPauseIcon.setVisibility(View.INVISIBLE);
+            if (!showCoverArt) {
+                holder.item.trackNumberTextView.setVisibility(View.VISIBLE);
+            } else {
+                holder.item.coverArtOverlay.setVisibility(View.INVISIBLE);
+            }
+        }
     }
 
     @Override
@@ -188,6 +262,46 @@ public class SongHorizontalAdapter extends RecyclerView.Adapter<SongHorizontalAd
         return position;
     }
 
+    public void setPlaybackState(String mediaId, boolean playing) {
+        String oldId = this.currentPlayingId;
+        boolean oldPlaying = this.isPlaying;
+        List<Integer> oldPositions = currentPlayingPositions;
+
+        this.currentPlayingId = mediaId;
+        this.isPlaying = playing;
+
+        if (Objects.equals(oldId, mediaId) && oldPlaying == playing) {
+            List<Integer> newPositionsCheck = mediaId != null ? findPositionsById(mediaId) : Collections.emptyList();
+            if (oldPositions.equals(newPositionsCheck)) {
+                return;
+            }
+        }
+
+        currentPlayingPositions = mediaId != null ? findPositionsById(mediaId) : Collections.emptyList();
+
+        for (int pos : oldPositions) {
+            if (pos >= 0 && pos < songs.size()) {
+                notifyItemChanged(pos, "payload_playback");
+            }
+        }
+        for (int pos : currentPlayingPositions) {
+            if (!oldPositions.contains(pos) && pos >= 0 && pos < songs.size()) {
+                notifyItemChanged(pos, "payload_playback");
+            }
+        }
+    }
+
+    private List<Integer> findPositionsById(String id) {
+        if (id == null) return Collections.emptyList();
+        List<Integer> positions = new ArrayList<>();
+        for (int i = 0; i < songs.size(); i++) {
+            if (id.equals(songs.get(i).getId())) {
+                positions.add(i);
+            }
+        }
+        return positions;
+    }
+
     @Override
     public Filter getFilter() {
         return filtering;
@@ -215,11 +329,29 @@ public class SongHorizontalAdapter extends RecyclerView.Adapter<SongHorizontalAd
         }
 
         public void onClick() {
+            int pos = getBindingAdapterPosition();
+            Child tappedSong = songs.get(pos);
+
             Bundle bundle = new Bundle();
             bundle.putParcelableArrayList(Constants.TRACKS_OBJECT, new ArrayList<>(MusicUtil.limitPlayableMedia(songs, getBindingAdapterPosition())));
             bundle.putInt(Constants.ITEM_POSITION, MusicUtil.getPlayableMediaPosition(songs, getBindingAdapterPosition()));
 
-            click.onMediaClick(bundle);
+            if (tappedSong.getId().equals(currentPlayingId)) {
+                Log.i("SongHorizontalAdapter", "Tapping on currently playing song, toggling playback");
+                try{
+                    MediaBrowser mediaBrowser = mediaBrowserListenableFuture.get();
+                    Log.i("SongHorizontalAdapter", "MediaBrowser retrieved, isPlaying: " + isPlaying);
+                    if (isPlaying) {
+                        mediaBrowser.pause();
+                    } else {
+                        mediaBrowser.play();
+                    }
+                } catch (ExecutionException | InterruptedException e) {
+                    Log.e("SongHorizontalAdapter", "Error getting MediaBrowser", e);
+                }
+            } else {
+                click.onMediaClick(bundle);
+            }
         }
 
         private boolean onLongClick() {
@@ -247,4 +379,8 @@ public class SongHorizontalAdapter extends RecyclerView.Adapter<SongHorizontalAd
 
         notifyDataSetChanged();
     }
+
+    public void setMediaBrowserListenableFuture(ListenableFuture<MediaBrowser> mediaBrowserListenableFuture) {
+        this.mediaBrowserListenableFuture = mediaBrowserListenableFuture;
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/ui/dialog/DeleteDownloadStorageDialog.java

@@ -3,6 +3,9 @@ package com.cappielloantonio.tempo.ui.dialog;
 import android.app.Dialog;
 import android.os.Bundle;
 import android.widget.Button;
+import android.net.Uri;
+
+import androidx.documentfile.provider.DocumentFile;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.OptIn;
@@ -12,6 +15,9 @@ import androidx.media3.common.util.UnstableApi;
 import com.cappielloantonio.tempo.R;
 import com.cappielloantonio.tempo.databinding.DialogDeleteDownloadStorageBinding;
 import com.cappielloantonio.tempo.util.DownloadUtil;
+import com.cappielloantonio.tempo.util.ExternalAudioReader;
+import com.cappielloantonio.tempo.util.ExternalDownloadMetadataStore;
+import com.cappielloantonio.tempo.util.Preferences;
 import com.google.android.material.dialog.MaterialAlertDialogBuilder;
 
 @OptIn(markerClass = UnstableApi.class)
@@ -42,7 +48,21 @@ public class DeleteDownloadStorageDialog extends DialogFragment {
         if (dialog != null) {
             Button positiveButton = dialog.getButton(Dialog.BUTTON_POSITIVE);
             positiveButton.setOnClickListener(v -> {
-                DownloadUtil.getDownloadTracker(requireContext()).removeAll();
+                if (Preferences.getDownloadDirectoryUri() == null) {
+                    DownloadUtil.getDownloadTracker(requireContext()).removeAll();
+                }
+
+                String uriString = Preferences.getDownloadDirectoryUri();
+                if (uriString != null) {
+                    DocumentFile directory = DocumentFile.fromTreeUri(requireContext(), Uri.parse(uriString));
+                    if (directory != null && directory.canWrite()) {
+                        for (DocumentFile file : directory.listFiles()) {
+                            file.delete();
+                        }
+                    }
+                    ExternalAudioReader.refreshCache();
+                    ExternalDownloadMetadataStore.clear();
+                }
                 dialog.dismiss();
             });
 

app/src/main/java/com/cappielloantonio/tempo/ui/dialog/DownloadDirectoryPickerDialog.java

@@ -0,0 +1,63 @@
+package com.cappielloantonio.tempo.ui.dialog;
+
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.widget.Toast;
+
+import androidx.activity.result.ActivityResultLauncher;
+import androidx.activity.result.contract.ActivityResultContracts;
+import androidx.annotation.NonNull;
+import androidx.fragment.app.DialogFragment;
+
+import com.google.android.material.dialog.MaterialAlertDialogBuilder;
+import com.cappielloantonio.tempo.R;
+import com.cappielloantonio.tempo.util.ExternalAudioReader;
+import com.cappielloantonio.tempo.util.Preferences;
+
+public class DownloadDirectoryPickerDialog extends DialogFragment {
+
+    private ActivityResultLauncher<Intent> folderPickerLauncher;
+
+    @NonNull
+    @Override
+    public android.app.Dialog onCreateDialog(Bundle savedInstanceState) {
+        // Register launcher *before* button triggers
+        folderPickerLauncher = registerForActivityResult(
+            new ActivityResultContracts.StartActivityForResult(),
+            result -> {
+                if (result.getResultCode() == android.app.Activity.RESULT_OK) {
+                    Intent data = result.getData();
+                    if (data != null) {
+                        Uri uri = data.getData();
+                        if (uri != null) {
+                            requireContext().getContentResolver().takePersistableUriPermission(
+                                uri,
+                                Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION
+                            );
+
+                            Preferences.setDownloadDirectoryUri(uri.toString());
+                            ExternalAudioReader.refreshCache();
+
+                            Toast.makeText(requireContext(), "Download directory set:\n" + uri.toString(), Toast.LENGTH_LONG).show();
+                        }
+                    }
+                }
+            }
+        );
+
+        return new MaterialAlertDialogBuilder(requireContext())
+            .setTitle("Set Download Directory")
+            .setMessage("Choose a folder where downloaded songs will be stored.")
+            .setPositiveButton("Choose Folder", (dialog, which) -> {
+                Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
+                intent.addFlags(Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION
+                              | Intent.FLAG_GRANT_READ_URI_PERMISSION
+                              | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
+                folderPickerLauncher.launch(intent);
+            })
+            .setNegativeButton(android.R.string.cancel, null)
+            .create();
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/ui/dialog/DownloadStorageDialog.java

@@ -34,6 +34,7 @@ public class DownloadStorageDialog extends DialogFragment {
                 .setTitle(R.string.download_storage_dialog_title)
                 .setPositiveButton(R.string.download_storage_external_dialog_positive_button, null)
                 .setNegativeButton(R.string.download_storage_internal_dialog_negative_button, null)
+                .setNeutralButton(R.string.download_storage_directory_dialog_neutral_button, null)
                 .create();
     }
 
@@ -74,6 +75,20 @@ public class DownloadStorageDialog extends DialogFragment {
 
                 dialog.dismiss();
             });
+
+            Button neutralButton = dialog.getButton(Dialog.BUTTON_NEUTRAL);
+            neutralButton.setOnClickListener(v -> {
+                int currentPreference = Preferences.getDownloadStoragePreference();
+                int newPreference = 2;
+
+                if (currentPreference != newPreference) {
+                    Preferences.setDownloadStoragePreference(newPreference);
+                    DownloadUtil.getDownloadTracker(requireContext()).removeAll();
+                    dialogClickCallback.onNeutralClick();
+                }
+
+                dialog.dismiss();
+            });
         }
     }
 }

app/src/main/java/com/cappielloantonio/tempo/ui/dialog/StarredArtistSyncDialog.java

@@ -0,0 +1,88 @@
+package com.cappielloantonio.tempo.ui.dialog;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.os.Bundle;
+import android.widget.Button;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.OptIn;
+import androidx.fragment.app.DialogFragment;
+import androidx.lifecycle.ViewModelProvider;
+import androidx.media3.common.util.UnstableApi;
+
+import com.cappielloantonio.tempo.R;
+import com.cappielloantonio.tempo.databinding.DialogStarredArtistSyncBinding;
+import com.cappielloantonio.tempo.model.Download;
+import com.cappielloantonio.tempo.util.DownloadUtil;
+import com.cappielloantonio.tempo.util.MappingUtil;
+import com.cappielloantonio.tempo.util.Preferences;
+import com.cappielloantonio.tempo.viewmodel.StarredArtistsSyncViewModel;
+import com.google.android.material.dialog.MaterialAlertDialogBuilder;
+
+import java.util.stream.Collectors;
+
+@OptIn(markerClass = UnstableApi.class)
+public class StarredArtistSyncDialog extends DialogFragment {
+    private StarredArtistsSyncViewModel starredArtistsSyncViewModel;
+
+    private Runnable onCancel;
+
+    public StarredArtistSyncDialog(Runnable onCancel) {
+        this.onCancel = onCancel;
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        DialogStarredArtistSyncBinding bind = DialogStarredArtistSyncBinding.inflate(getLayoutInflater());
+
+        starredArtistsSyncViewModel = new ViewModelProvider(requireActivity()).get(StarredArtistsSyncViewModel.class);
+
+        return new MaterialAlertDialogBuilder(getActivity())
+                .setView(bind.getRoot())
+                .setTitle(R.string.starred_artist_sync_dialog_title)
+                .setPositiveButton(R.string.starred_sync_dialog_positive_button, null)
+                .setNeutralButton(R.string.starred_sync_dialog_neutral_button, null)
+                .setNegativeButton(R.string.starred_sync_dialog_negative_button, null)
+                .create();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        setButtonAction(requireContext());
+    }
+
+    private void setButtonAction(Context context) {
+        androidx.appcompat.app.AlertDialog dialog = (androidx.appcompat.app.AlertDialog) getDialog();
+
+        if (dialog != null) {
+            Button positiveButton = dialog.getButton(Dialog.BUTTON_POSITIVE);
+            positiveButton.setOnClickListener(v -> {
+                starredArtistsSyncViewModel.getStarredArtistSongs(requireActivity()).observe(this, allSongs -> {
+                    if (allSongs != null && !allSongs.isEmpty()) {
+                        DownloadUtil.getDownloadTracker(context).download(
+                                MappingUtil.mapDownloads(allSongs),
+                                allSongs.stream().map(Download::new).collect(Collectors.toList())
+                        );
+                    }
+                    dialog.dismiss();
+                });
+            });
+
+            Button neutralButton = dialog.getButton(Dialog.BUTTON_NEUTRAL);
+            neutralButton.setOnClickListener(v -> {
+                Preferences.setStarredArtistsSyncEnabled(true);
+                dialog.dismiss();
+            });
+
+            Button negativeButton = dialog.getButton(Dialog.BUTTON_NEGATIVE);
+            negativeButton.setOnClickListener(v -> {
+                Preferences.setStarredArtistsSyncEnabled(false);
+                if (onCancel != null) onCancel.run();
+                dialog.dismiss();
+            });
+        }
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/ui/dialog/StarredSyncDialog.java

@@ -61,7 +61,7 @@ public class StarredSyncDialog extends DialogFragment {
             Button positiveButton = dialog.getButton(Dialog.BUTTON_POSITIVE);
             positiveButton.setOnClickListener(v -> {
                 starredSyncViewModel.getStarredTracks(requireActivity()).observe(requireActivity(), songs -> {
-                    if (songs != null) {
+                    if (songs != null && Preferences.getDownloadDirectoryUri() == null) {
                         DownloadUtil.getDownloadTracker(context).download(
                                 MappingUtil.mapDownloads(songs),
                                 songs.stream().map(Download::new).collect(Collectors.toList())

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/AlbumPageFragment.java

@@ -39,7 +39,10 @@ import com.cappielloantonio.tempo.util.Constants;
 import com.cappielloantonio.tempo.util.DownloadUtil;
 import com.cappielloantonio.tempo.util.MappingUtil;
 import com.cappielloantonio.tempo.util.MusicUtil;
+import com.cappielloantonio.tempo.util.ExternalAudioWriter;
+import com.cappielloantonio.tempo.util.Preferences;
 import com.cappielloantonio.tempo.viewmodel.AlbumPageViewModel;
+import com.cappielloantonio.tempo.viewmodel.PlaybackViewModel;
 import com.google.common.util.concurrent.ListenableFuture;
 
 import java.util.ArrayList;
@@ -52,6 +55,7 @@ public class AlbumPageFragment extends Fragment implements ClickCallback {
     private FragmentAlbumPageBinding bind;
     private MainActivity activity;
     private AlbumPageViewModel albumPageViewModel;
+    private PlaybackViewModel playbackViewModel;
     private SongHorizontalAdapter songHorizontalAdapter;
     private ListenableFuture<MediaBrowser> mediaBrowserListenableFuture;
 
@@ -74,6 +78,7 @@ public class AlbumPageFragment extends Fragment implements ClickCallback {
         bind = FragmentAlbumPageBinding.inflate(inflater, container, false);
         View view = bind.getRoot();
         albumPageViewModel = new ViewModelProvider(requireActivity()).get(AlbumPageViewModel.class);
+        playbackViewModel = new ViewModelProvider(requireActivity()).get(PlaybackViewModel.class);
 
         init();
         initAppBar();
@@ -91,6 +96,14 @@ public class AlbumPageFragment extends Fragment implements ClickCallback {
         super.onStart();
 
         initializeMediaBrowser();
+
+        MediaManager.registerPlaybackObserver(mediaBrowserListenableFuture, playbackViewModel);
+        observePlayback();
+    }
+
+    public void onResume() {
+        super.onResume();
+        if (songHorizontalAdapter != null) setMediaBrowserListenableFuture();
     }
 
     @Override
@@ -119,7 +132,14 @@ public class AlbumPageFragment extends Fragment implements ClickCallback {
 
         if (item.getItemId() == R.id.action_download_album) {
             albumPageViewModel.getAlbumSongLiveList().observe(getViewLifecycleOwner(), songs -> {
-                DownloadUtil.getDownloadTracker(requireContext()).download(MappingUtil.mapDownloads(songs), songs.stream().map(Download::new).collect(Collectors.toList()));
+                if (Preferences.getDownloadDirectoryUri() == null) {
+                    DownloadUtil.getDownloadTracker(requireContext()).download(
+                        MappingUtil.mapDownloads(songs),
+                        songs.stream().map(Download::new).collect(Collectors.toList())
+                    );
+                } else {
+                    songs.forEach(child -> ExternalAudioWriter.downloadToUserDirectory(requireContext(), child));
+                }
             });
             return true;
         }
@@ -269,10 +289,15 @@ public class AlbumPageFragment extends Fragment implements ClickCallback {
                 bind.songRecyclerView.setLayoutManager(new LinearLayoutManager(requireContext()));
                 bind.songRecyclerView.setHasFixedSize(true);
 
-                songHorizontalAdapter = new SongHorizontalAdapter(this, false, false, album);
+                songHorizontalAdapter = new SongHorizontalAdapter(getViewLifecycleOwner(), this, false, false, album);
                 bind.songRecyclerView.setAdapter(songHorizontalAdapter);
+                setMediaBrowserListenableFuture();
+                reapplyPlayback();
 
-                albumPageViewModel.getAlbumSongLiveList().observe(getViewLifecycleOwner(), songs -> songHorizontalAdapter.setItems(songs));
+                albumPageViewModel.getAlbumSongLiveList().observe(getViewLifecycleOwner(), songs -> {
+                    songHorizontalAdapter.setItems(songs);
+                    reapplyPlayback();
+                });
             }
         });
     }
@@ -295,4 +320,31 @@ public class AlbumPageFragment extends Fragment implements ClickCallback {
     public void onMediaLongClick(Bundle bundle) {
         Navigation.findNavController(requireView()).navigate(R.id.songBottomSheetDialog, bundle);
     }
+
+    private void observePlayback() {
+        playbackViewModel.getCurrentSongId().observe(getViewLifecycleOwner(), id -> {
+            if (songHorizontalAdapter != null) {
+                Boolean playing = playbackViewModel.getIsPlaying().getValue();
+                songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+        playbackViewModel.getIsPlaying().observe(getViewLifecycleOwner(), playing -> {
+            if (songHorizontalAdapter != null) {
+                String id = playbackViewModel.getCurrentSongId().getValue();
+                songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+    }
+
+    private void reapplyPlayback() {
+        if (songHorizontalAdapter != null) {
+            String id = playbackViewModel.getCurrentSongId().getValue();
+            Boolean playing = playbackViewModel.getIsPlaying().getValue();
+            songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+        }
+    }
+
+    private void setMediaBrowserListenableFuture() {
+        songHorizontalAdapter.setMediaBrowserListenableFuture(mediaBrowserListenableFuture);
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/ArtistPageFragment.java

@@ -29,19 +29,16 @@ import com.cappielloantonio.tempo.service.MediaManager;
 import com.cappielloantonio.tempo.service.MediaService;
 import com.cappielloantonio.tempo.subsonic.models.ArtistID3;
 import com.cappielloantonio.tempo.ui.activity.MainActivity;
-import com.cappielloantonio.tempo.ui.adapter.AlbumArtistPageOrSimilarAdapter;
 import com.cappielloantonio.tempo.ui.adapter.AlbumCatalogueAdapter;
 import com.cappielloantonio.tempo.ui.adapter.ArtistCatalogueAdapter;
-import com.cappielloantonio.tempo.ui.adapter.ArtistSimilarAdapter;
 import com.cappielloantonio.tempo.ui.adapter.SongHorizontalAdapter;
 import com.cappielloantonio.tempo.util.Constants;
 import com.cappielloantonio.tempo.util.MusicUtil;
-import com.cappielloantonio.tempo.util.Preferences;
 import com.cappielloantonio.tempo.viewmodel.ArtistPageViewModel;
+import com.cappielloantonio.tempo.viewmodel.PlaybackViewModel;
 import com.google.common.util.concurrent.ListenableFuture;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
 @UnstableApi
@@ -49,6 +46,7 @@ public class ArtistPageFragment extends Fragment implements ClickCallback {
     private FragmentArtistPageBinding bind;
     private MainActivity activity;
     private ArtistPageViewModel artistPageViewModel;
+    private PlaybackViewModel playbackViewModel;
 
     private SongHorizontalAdapter songHorizontalAdapter;
     private AlbumCatalogueAdapter albumCatalogueAdapter;
@@ -63,6 +61,7 @@ public class ArtistPageFragment extends Fragment implements ClickCallback {
         bind = FragmentArtistPageBinding.inflate(inflater, container, false);
         View view = bind.getRoot();
         artistPageViewModel = new ViewModelProvider(requireActivity()).get(ArtistPageViewModel.class);
+        playbackViewModel = new ViewModelProvider(requireActivity()).get(PlaybackViewModel.class);
 
         init();
         initAppBar();
@@ -80,6 +79,13 @@ public class ArtistPageFragment extends Fragment implements ClickCallback {
         super.onStart();
 
         initializeMediaBrowser();
+        MediaManager.registerPlaybackObserver(mediaBrowserListenableFuture, playbackViewModel);
+        observePlayback();
+    }
+
+    public void onResume() {
+        super.onResume();
+        if (songHorizontalAdapter != null) setMediaBrowserListenableFuture();
     }
 
     @Override
@@ -159,7 +165,7 @@ public class ArtistPageFragment extends Fragment implements ClickCallback {
 
         bind.artistPageRadioButton.setOnClickListener(v -> {
             artistPageViewModel.getArtistInstantMix().observe(getViewLifecycleOwner(), songs -> {
-                if (!songs.isEmpty()) {
+                if (songs != null && !songs.isEmpty()) {
                     MediaManager.startQueue(mediaBrowserListenableFuture, songs, 0);
                     activity.setBottomSheetInPeek(true);
                 } else {
@@ -172,8 +178,10 @@ public class ArtistPageFragment extends Fragment implements ClickCallback {
     private void initTopSongsView() {
         bind.mostStreamedSongRecyclerView.setLayoutManager(new LinearLayoutManager(requireContext()));
 
-        songHorizontalAdapter = new SongHorizontalAdapter(this, true, true, null);
+        songHorizontalAdapter = new SongHorizontalAdapter(getViewLifecycleOwner(), this, true, true, null);
         bind.mostStreamedSongRecyclerView.setAdapter(songHorizontalAdapter);
+        setMediaBrowserListenableFuture();
+        reapplyPlayback();
         artistPageViewModel.getArtistTopSongList().observe(getViewLifecycleOwner(), songs -> {
             if (songs == null) {
                 if (bind != null) bind.artistPageTopSongsSector.setVisibility(View.GONE);
@@ -183,6 +191,7 @@ public class ArtistPageFragment extends Fragment implements ClickCallback {
                 if (bind != null)
                     bind.artistPageShuffleButton.setEnabled(!songs.isEmpty());
                 songHorizontalAdapter.setItems(songs);
+                reapplyPlayback();
             }
         });
     }
@@ -273,4 +282,31 @@ public class ArtistPageFragment extends Fragment implements ClickCallback {
     public void onArtistLongClick(Bundle bundle) {
         Navigation.findNavController(requireView()).navigate(R.id.artistBottomSheetDialog, bundle);
     }
+
+    private void observePlayback() {
+        playbackViewModel.getCurrentSongId().observe(getViewLifecycleOwner(), id -> {
+            if (songHorizontalAdapter != null) {
+                Boolean playing = playbackViewModel.getIsPlaying().getValue();
+                songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+        playbackViewModel.getIsPlaying().observe(getViewLifecycleOwner(), playing -> {
+            if (songHorizontalAdapter != null) {
+                String id = playbackViewModel.getCurrentSongId().getValue();
+                songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+    }
+
+    private void reapplyPlayback() {
+        if (songHorizontalAdapter != null) {
+            String id = playbackViewModel.getCurrentSongId().getValue();
+            Boolean playing = playbackViewModel.getIsPlaying().getValue();
+            songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+        }
+    }
+
+    private void setMediaBrowserListenableFuture() {
+        songHorizontalAdapter.setMediaBrowserListenableFuture(mediaBrowserListenableFuture);
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/DirectoryFragment.java

@@ -33,7 +33,9 @@ import com.cappielloantonio.tempo.ui.adapter.MusicDirectoryAdapter;
 import com.cappielloantonio.tempo.ui.dialog.DownloadDirectoryDialog;
 import com.cappielloantonio.tempo.util.Constants;
 import com.cappielloantonio.tempo.util.DownloadUtil;
+import com.cappielloantonio.tempo.util.ExternalAudioWriter;
 import com.cappielloantonio.tempo.util.MappingUtil;
+import com.cappielloantonio.tempo.util.Preferences;
 import com.cappielloantonio.tempo.viewmodel.DirectoryViewModel;
 import com.google.common.util.concurrent.ListenableFuture;
 
@@ -109,10 +111,14 @@ public class DirectoryFragment extends Fragment implements ClickCallback {
                     directoryViewModel.loadMusicDirectory(getArguments().getString(Constants.MUSIC_DIRECTORY_ID)).observe(getViewLifecycleOwner(), directory -> {
                         if (isVisible() && getActivity() != null) {
                             List<Child> songs = directory.getChildren().stream().filter(child -> !child.isDir()).collect(Collectors.toList());
-                            DownloadUtil.getDownloadTracker(requireContext()).download(
-                                    MappingUtil.mapDownloads(songs),
-                                    songs.stream().map(Download::new).collect(Collectors.toList())
-                            );
+                            if (Preferences.getDownloadDirectoryUri() == null) {
+                                DownloadUtil.getDownloadTracker(requireContext()).download(
+                                        MappingUtil.mapDownloads(songs),
+                                        songs.stream().map(Download::new).collect(Collectors.toList())
+                                );
+                            } else {
+                                songs.forEach(child -> ExternalAudioWriter.downloadToUserDirectory(requireContext(), child));
+                            }
                         }
                     });
                 }

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/DownloadFragment.java

@@ -28,11 +28,17 @@ import com.cappielloantonio.tempo.subsonic.models.Child;
 import com.cappielloantonio.tempo.ui.activity.MainActivity;
 import com.cappielloantonio.tempo.ui.adapter.DownloadHorizontalAdapter;
 import com.cappielloantonio.tempo.util.Constants;
+import com.cappielloantonio.tempo.util.ExternalAudioReader;
 import com.cappielloantonio.tempo.util.Preferences;
 import com.cappielloantonio.tempo.viewmodel.DownloadViewModel;
 import com.google.android.material.appbar.MaterialToolbar;
 import com.google.common.util.concurrent.ListenableFuture;
 
+import android.content.Intent;
+import android.app.Activity;
+import android.net.Uri;
+import android.widget.Toast;
+
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
@@ -40,6 +46,7 @@ import java.util.Objects;
 @UnstableApi
 public class DownloadFragment extends Fragment implements ClickCallback {
     private static final String TAG = "DownloadFragment";
+    private static final int REQUEST_CODE_PICK_DIRECTORY = 1002;
 
     private FragmentDownloadBinding bind;
     private MainActivity activity;
@@ -129,8 +136,27 @@ public class DownloadFragment extends Fragment implements ClickCallback {
             }
         });
 
+        downloadViewModel.getRefreshResult().observe(getViewLifecycleOwner(), count -> {
+            if (count == null || bind == null) {
+                return;
+            }
+
+            if (count == -1) {
+                Toast.makeText(requireContext(), R.string.download_refresh_no_directory, Toast.LENGTH_SHORT).show();
+            } else if (count == 0) {
+                Toast.makeText(requireContext(), R.string.download_refresh_no_changes, Toast.LENGTH_SHORT).show();
+            } else {
+                Toast.makeText(
+                        requireContext(),
+                        getResources().getQuantityString(R.plurals.download_refresh_removed, count, count),
+                        Toast.LENGTH_SHORT
+                ).show();
+            }
+        });
+
         bind.downloadedGroupByImageView.setOnClickListener(view -> showPopupMenu(view, R.menu.download_popup_menu));
         bind.downloadedGoBackImageView.setOnClickListener(view -> downloadViewModel.popViewStack());
+        bind.downloadedRefreshImageView.setOnClickListener(view -> downloadViewModel.refreshExternalDownloads());
     }
 
     private void finishDownloadView(List<Child> songs) {
@@ -216,6 +242,10 @@ public class DownloadFragment extends Fragment implements ClickCallback {
                 downloadViewModel.initViewStack(new DownloadStack(Constants.DOWNLOAD_TYPE_YEAR, null));
                 Preferences.setDefaultDownloadViewType(Constants.DOWNLOAD_TYPE_YEAR);
                 return true;
+            } else if (menuItem.getItemId() == R.id.menu_download_set_directory) { 
+                Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
+                startActivityForResult(intent, REQUEST_CODE_PICK_DIRECTORY);
+                return true;
             }
 
             return false;
@@ -267,4 +297,21 @@ public class DownloadFragment extends Fragment implements ClickCallback {
     public void onDownloadGroupLongClick(Bundle bundle) {
         Navigation.findNavController(requireView()).navigate(R.id.downloadBottomSheetDialog, bundle);
     }
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+        if (requestCode == REQUEST_CODE_PICK_DIRECTORY && resultCode == Activity.RESULT_OK) {
+            Uri uri = data.getData();
+            if (uri != null) {
+                requireContext().getContentResolver().takePersistableUriPermission(
+                        uri,
+                        Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION
+                );
+                Preferences.setDownloadDirectoryUri(uri.toString());
+                ExternalAudioReader.refreshCache();
+                Toast.makeText(requireContext(), "Download directory set", Toast.LENGTH_SHORT).show();
+            }
+        }
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/EqualizerFragment.kt

@@ -0,0 +1,237 @@
+package com.cappielloantonio.tempo.ui.fragment
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.os.Bundle
+import android.os.IBinder
+import android.view.Gravity
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.*
+import androidx.annotation.OptIn
+import androidx.fragment.app.Fragment
+import androidx.media3.common.util.UnstableApi
+import com.cappielloantonio.tempo.R
+import com.cappielloantonio.tempo.service.EqualizerManager
+import com.cappielloantonio.tempo.service.MediaService
+import com.cappielloantonio.tempo.util.Preferences
+
+class EqualizerFragment : Fragment() {
+
+    private var equalizerManager: EqualizerManager? = null
+    private lateinit var eqBandsContainer: LinearLayout
+    private lateinit var eqSwitch: Switch
+    private lateinit var resetButton: Button
+    private lateinit var safeSpace: Space
+    private val bandSeekBars = mutableListOf<SeekBar>()
+
+    private val connection = object : ServiceConnection {
+        @OptIn(UnstableApi::class)
+        override fun onServiceConnected(className: ComponentName, service: IBinder) {
+            val binder = service as MediaService.LocalBinder
+            equalizerManager = binder.getEqualizerManager()
+            initUI()
+            restoreEqualizerPreferences()
+        }
+
+        override fun onServiceDisconnected(arg0: ComponentName) {
+            equalizerManager = null
+        }
+    }
+
+    @OptIn(UnstableApi::class)
+    override fun onStart() {
+        super.onStart()
+        Intent(requireContext(), MediaService::class.java).also { intent ->
+            intent.action = MediaService.ACTION_BIND_EQUALIZER
+            requireActivity().bindService(intent, connection, Context.BIND_AUTO_CREATE)
+        }
+    }
+
+    override fun onStop() {
+        super.onStop()
+        requireActivity().unbindService(connection)
+        equalizerManager = null
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater, container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View? {
+        val root = inflater.inflate(R.layout.fragment_equalizer, container, false)
+        eqSwitch = root.findViewById(R.id.equalizer_switch)
+        eqSwitch.isChecked = Preferences.isEqualizerEnabled()
+        eqSwitch.jumpDrawablesToCurrentState()
+        return root
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        eqBandsContainer = view.findViewById(R.id.eq_bands_container)
+        resetButton = view.findViewById(R.id.equalizer_reset_button)
+        safeSpace = view.findViewById(R.id.equalizer_bottom_space)
+    }
+
+    private fun initUI() {
+        val manager = equalizerManager
+        val notSupportedView = view?.findViewById<LinearLayout>(R.id.equalizer_not_supported_container)
+        val switchRow = view?.findViewById<View>(R.id.equalizer_switch_row)
+
+        if (manager == null || manager.getNumberOfBands().toInt() == 0) {
+            switchRow?.visibility = View.GONE
+            resetButton.visibility = View.GONE
+            eqBandsContainer.visibility = View.GONE
+            safeSpace.visibility = View.GONE
+            notSupportedView?.visibility = View.VISIBLE
+            return
+        }
+
+        notSupportedView?.visibility = View.GONE
+        switchRow?.visibility = View.VISIBLE
+        resetButton.visibility = View.VISIBLE
+        eqBandsContainer.visibility = View.VISIBLE
+        safeSpace.visibility = View.VISIBLE
+
+        eqSwitch.setOnCheckedChangeListener(null)
+        updateUiEnabledState(eqSwitch.isChecked)
+        eqSwitch.setOnCheckedChangeListener { _, isChecked ->
+            manager.setEnabled(isChecked)
+            Preferences.setEqualizerEnabled(isChecked)
+            updateUiEnabledState(isChecked)
+        }
+
+        createBandSliders()
+
+        resetButton.setOnClickListener {
+            resetEqualizer()
+            saveBandLevelsToPreferences()
+        }
+    }
+
+    private fun updateUiEnabledState(isEnabled: Boolean) {
+        resetButton.isEnabled = isEnabled
+        bandSeekBars.forEach { it.isEnabled = isEnabled }
+    }
+
+    private fun formatDb(value: Int): String = if (value > 0) "+$value dB" else "$value dB"
+
+    private fun createBandSliders() {
+        val manager = equalizerManager ?: return
+        eqBandsContainer.removeAllViews()
+        bandSeekBars.clear()
+        val bands = manager.getNumberOfBands()
+        val bandLevelRange = manager.getBandLevelRange() ?: shortArrayOf(-1500, 1500)
+        val minLevelDb = bandLevelRange[0] / 100
+        val maxLevelDb = bandLevelRange[1] / 100
+
+        val savedLevels = Preferences.getEqualizerBandLevels(bands)
+        for (i in 0 until bands) {
+            val band = i.toShort()
+            val freq = manager.getCenterFreq(band) ?: 0
+
+            val row = LinearLayout(requireContext()).apply {
+                orientation = LinearLayout.HORIZONTAL
+                layoutParams = LinearLayout.LayoutParams(
+                    LinearLayout.LayoutParams.MATCH_PARENT,
+                    LinearLayout.LayoutParams.WRAP_CONTENT
+                ).apply {
+                    val topBottomMarginDp = 16
+                    topMargin = topBottomMarginDp.dpToPx(context)
+                    bottomMargin = topBottomMarginDp.dpToPx(context)
+                }
+                setPadding(0, 8, 0, 8)
+            }
+
+            val freqLabel = TextView(requireContext(), null, 0, R.style.LabelSmall).apply {
+                text = if (freq >= 1000) {
+                    if (freq % 1000 == 0) {
+                        "${freq / 1000} kHz"
+                    } else {
+                        String.format("%.1f kHz", freq / 1000f)
+                    }
+                } else {
+                    "$freq Hz"
+                }
+                gravity = Gravity.START
+                layoutParams = LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 2f)
+            }
+            row.addView(freqLabel)
+
+            val initialLevelDb = (savedLevels.getOrNull(i) ?: (manager.getBandLevel(band) ?: 0)) / 100
+            val dbLabel = TextView(requireContext(), null, 0, R.style.LabelSmall).apply {
+                text = formatDb(initialLevelDb)
+                setPadding(12, 0, 0, 0)
+                gravity = Gravity.END
+                layoutParams = LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 2f)
+            }
+
+            val seekBar = SeekBar(requireContext()).apply {
+                max = maxLevelDb - minLevelDb
+                progress = initialLevelDb - minLevelDb
+                layoutParams = LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 6f)
+                setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
+                    override fun onProgressChanged(seekBar: SeekBar, progress: Int, fromUser: Boolean) {
+                        val thisLevelDb = progress + minLevelDb
+                        if (fromUser) {
+                            manager.setBandLevel(band, (thisLevelDb * 100).toShort())
+                            saveBandLevelsToPreferences()
+                        }
+                        dbLabel.text = formatDb(thisLevelDb)
+                    }
+
+                    override fun onStartTrackingTouch(seekBar: SeekBar) {}
+                    override fun onStopTrackingTouch(seekBar: SeekBar) {}
+                })
+            }
+            bandSeekBars.add(seekBar)
+            row.addView(seekBar)
+            row.addView(dbLabel)
+            eqBandsContainer.addView(row)
+        }
+    }
+
+    private fun resetEqualizer() {
+        val manager = equalizerManager ?: return
+        val bands = manager.getNumberOfBands()
+        val bandLevelRange = manager.getBandLevelRange() ?: shortArrayOf(-1500, 1500)
+        val minLevelDb = bandLevelRange[0] / 100
+        val midLevelDb = 0
+
+        for (i in 0 until bands) {
+            manager.setBandLevel(i.toShort(), (0).toShort())
+            bandSeekBars.getOrNull(i)?.progress = midLevelDb - minLevelDb
+        }
+        Preferences.setEqualizerBandLevels(ShortArray(bands.toInt()))
+    }
+
+    private fun saveBandLevelsToPreferences() {
+        val manager = equalizerManager ?: return
+        val bands = manager.getNumberOfBands()
+        val levels = ShortArray(bands.toInt()) { i -> manager.getBandLevel(i.toShort()) ?: 0 }
+        Preferences.setEqualizerBandLevels(levels)
+    }
+
+    private fun restoreEqualizerPreferences() {
+        val manager = equalizerManager ?: return
+        eqSwitch.isChecked = Preferences.isEqualizerEnabled()
+        updateUiEnabledState(eqSwitch.isChecked)
+
+        val bands = manager.getNumberOfBands()
+        val bandLevelRange = manager.getBandLevelRange() ?: shortArrayOf(-1500, 1500)
+        val minLevelDb = bandLevelRange[0] / 100
+
+        val savedLevels = Preferences.getEqualizerBandLevels(bands)
+        for (i in 0 until bands) {
+            val savedDb = savedLevels[i] / 100
+            manager.setBandLevel(i.toShort(), (savedDb * 100).toShort())
+            bandSeekBars.getOrNull(i)?.progress = savedDb - minLevelDb
+        }
+    }
+
+}
+
+private fun Int.dpToPx(context: Context): Int =
+    (this * context.resources.displayMetrics.density).toInt()

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/HomeTabMusicFragment.java

@@ -9,6 +9,7 @@ import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.PopupMenu;
+import android.widget.Toast;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -40,6 +41,7 @@ import com.cappielloantonio.tempo.service.MediaService;
 import com.cappielloantonio.tempo.subsonic.models.Child;
 import com.cappielloantonio.tempo.subsonic.models.Share;
 import com.cappielloantonio.tempo.subsonic.models.AlbumID3;
+import com.cappielloantonio.tempo.subsonic.models.ArtistID3;
 import com.cappielloantonio.tempo.ui.activity.MainActivity;
 import com.cappielloantonio.tempo.ui.adapter.AlbumAdapter;
 import com.cappielloantonio.tempo.ui.adapter.AlbumHorizontalAdapter;
@@ -60,9 +62,12 @@ import com.cappielloantonio.tempo.util.MusicUtil;
 import com.cappielloantonio.tempo.util.Preferences;
 import com.cappielloantonio.tempo.util.UIUtil;
 import com.cappielloantonio.tempo.viewmodel.HomeViewModel;
+import com.cappielloantonio.tempo.viewmodel.PlaybackViewModel;
 import com.google.android.material.snackbar.Snackbar;
 import com.google.common.util.concurrent.ListenableFuture;
 
+import androidx.media3.common.MediaItem;
+
 import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Collectors;
@@ -74,6 +79,7 @@ public class HomeTabMusicFragment extends Fragment implements ClickCallback {
     private FragmentHomeTabMusicBinding bind;
     private MainActivity activity;
     private HomeViewModel homeViewModel;
+    private PlaybackViewModel playbackViewModel;
 
     private DiscoverSongAdapter discoverSongAdapter;
     private SimilarTrackAdapter similarMusicAdapter;
@@ -101,6 +107,7 @@ public class HomeTabMusicFragment extends Fragment implements ClickCallback {
         bind = FragmentHomeTabMusicBinding.inflate(inflater, container, false);
         View view = bind.getRoot();
         homeViewModel = new ViewModelProvider(requireActivity()).get(HomeViewModel.class);
+        playbackViewModel = new ViewModelProvider(requireActivity()).get(PlaybackViewModel.class);
 
         init();
 
@@ -113,6 +120,7 @@ public class HomeTabMusicFragment extends Fragment implements ClickCallback {
 
         initSyncStarredView();
         initSyncStarredAlbumsView();
+        initSyncStarredArtistsView();
         initDiscoverSongSlideView();
         initSimilarSongView();
         initArtistRadio();
@@ -138,12 +146,18 @@ public class HomeTabMusicFragment extends Fragment implements ClickCallback {
         super.onStart();
 
         initializeMediaBrowser();
+
+        MediaManager.registerPlaybackObserver(mediaBrowserListenableFuture, playbackViewModel);
+        observeStarredSongsPlayback();
+        observeTopSongsPlayback();
     }
 
     @Override
     public void onResume() {
         super.onResume();
         refreshSharesView();
+        if (topSongAdapter != null) setTopSongsMediaBrowserListenableFuture();
+        if (starredSongAdapter != null) setStarredSongsMediaBrowserListenableFuture();
     }
 
     @Override
@@ -265,7 +279,7 @@ public class HomeTabMusicFragment extends Fragment implements ClickCallback {
     }
 
     private void initSyncStarredView() {
-        if (Preferences.isStarredSyncEnabled()) {
+        if (Preferences.isStarredSyncEnabled() && Preferences.getDownloadDirectoryUri() == null) {
             homeViewModel.getAllStarredTracks().observeForever(new Observer<List<Child>>() {
                 @Override
                 public void onChanged(List<Child> songs) {
@@ -318,32 +332,12 @@ public class HomeTabMusicFragment extends Fragment implements ClickCallback {
 
     private void initSyncStarredAlbumsView() {
         if (Preferences.isStarredAlbumsSyncEnabled()) {
-            homeViewModel.getStarredAlbums(getViewLifecycleOwner()).observeForever(new Observer<List<AlbumID3>>() {
+            homeViewModel.getStarredAlbums(getViewLifecycleOwner()).observe(getViewLifecycleOwner(), new Observer<List<AlbumID3>>() {
                 @Override
                 public void onChanged(List<AlbumID3> albums) {
-                    if (albums != null) {
-                        DownloaderManager manager = DownloadUtil.getDownloadTracker(requireContext());
-                        List<String> albumsToSync = new ArrayList<>();
-                        int albumCount = 0;
-
-                        for (AlbumID3 album : albums) {
-                            boolean needsSync = false;
-                            albumCount++;
-                            albumsToSync.add(album.getName());
-                        }
-
-                        if (albumCount > 0) {
-                            bind.homeSyncStarredAlbumsCard.setVisibility(View.VISIBLE);
-                            String message = getResources().getQuantityString(
-                                R.plurals.home_sync_starred_albums_count, 
-                                albumCount, 
-                                albumCount
-                            );
-                            bind.homeSyncStarredAlbumsToSync.setText(message);
-                        }
+                    if (albums != null && !albums.isEmpty()) {
+                        checkIfAlbumsNeedSync(albums);
                     }
-
-                    homeViewModel.getStarredAlbums(getViewLifecycleOwner()).removeObserver(this);
                 }
             });
         }
@@ -353,26 +347,157 @@ public class HomeTabMusicFragment extends Fragment implements ClickCallback {
         });
 
         bind.homeSyncStarredAlbumsDownload.setOnClickListener(v -> {
-            homeViewModel.getAllStarredAlbumSongs().observeForever(new Observer<List<Child>>() {
+            homeViewModel.getAllStarredAlbumSongs().observe(getViewLifecycleOwner(), new Observer<List<Child>>() {
                 @Override
                 public void onChanged(List<Child> allSongs) {
-                    if (allSongs != null) {
+                    if (allSongs != null && !allSongs.isEmpty()) {
                         DownloaderManager manager = DownloadUtil.getDownloadTracker(requireContext());
+                        int songsToDownload = 0;
 
                         for (Child song : allSongs) {
                             if (!manager.isDownloaded(song.getId())) {
                                 manager.download(MappingUtil.mapDownload(song), new Download(song));
+                                songsToDownload++;
                             }
                         }
-                    }
 
-                    homeViewModel.getAllStarredAlbumSongs().removeObserver(this);
+                        if (songsToDownload > 0) {
+                            Toast.makeText(requireContext(), 
+                                getResources().getQuantityString(R.plurals.songs_download_started, songsToDownload, songsToDownload), 
+                                Toast.LENGTH_SHORT).show();
+                        }
+                    }
+                    
                     bind.homeSyncStarredAlbumsCard.setVisibility(View.GONE);
                 }
             });
         });
     }
 
+    private void checkIfAlbumsNeedSync(List<AlbumID3> albums) {
+        homeViewModel.getAllStarredAlbumSongs().observe(getViewLifecycleOwner(), new Observer<List<Child>>() {
+            @Override
+            public void onChanged(List<Child> allSongs) {
+                if (allSongs != null) {
+                    DownloaderManager manager = DownloadUtil.getDownloadTracker(requireContext());
+                    int songsToDownload = 0;
+                    List<String> albumsNeedingSync = new ArrayList<>();
+
+                    for (AlbumID3 album : albums) {
+                        boolean albumNeedsSync = false;
+                        // Check if any songs from this album need downloading
+                        for (Child song : allSongs) {
+                            if (song.getAlbumId() != null && song.getAlbumId().equals(album.getId()) && 
+                                !manager.isDownloaded(song.getId())) {
+                                songsToDownload++;
+                                albumNeedsSync = true;
+                            }
+                        }
+                        if (albumNeedsSync) {
+                            albumsNeedingSync.add(album.getName());
+                        }
+                    }
+
+                    if (songsToDownload > 0) {
+                        bind.homeSyncStarredAlbumsCard.setVisibility(View.VISIBLE);
+                        String message = getResources().getQuantityString(
+                            R.plurals.home_sync_starred_albums_count, 
+                            albumsNeedingSync.size(), 
+                            albumsNeedingSync.size()
+                        );
+                        bind.homeSyncStarredAlbumsToSync.setText(message);
+                    } else {
+                        bind.homeSyncStarredAlbumsCard.setVisibility(View.GONE);
+                    }
+                }
+            }
+        });
+    }
+
+    private void initSyncStarredArtistsView() {
+        if (Preferences.isStarredArtistsSyncEnabled()) {
+            homeViewModel.getStarredArtists(getViewLifecycleOwner()).observe(getViewLifecycleOwner(), new Observer<List<ArtistID3>>() {
+                @Override
+                public void onChanged(List<ArtistID3> artists) {
+                    if (artists != null && !artists.isEmpty()) {
+                        checkIfArtistsNeedSync(artists);
+                    }
+                }
+            });
+        }
+
+        bind.homeSyncStarredArtistsCancel.setOnClickListener(v -> {
+            bind.homeSyncStarredArtistsCard.setVisibility(View.GONE);
+        });
+
+        bind.homeSyncStarredArtistsDownload.setOnClickListener(v -> {
+            homeViewModel.getAllStarredArtistSongs().observe(getViewLifecycleOwner(), new Observer<List<Child>>() {
+                @Override
+                public void onChanged(List<Child> allSongs) {
+                    if (allSongs != null && !allSongs.isEmpty()) {
+                        DownloaderManager manager = DownloadUtil.getDownloadTracker(requireContext());
+                        int songsToDownload = 0;
+
+                        for (Child song : allSongs) {
+                            if (!manager.isDownloaded(song.getId())) {
+                                manager.download(MappingUtil.mapDownload(song), new Download(song));
+                                songsToDownload++;
+                            }
+                        }
+
+                        if (songsToDownload > 0) {
+                            Toast.makeText(requireContext(), 
+                                getResources().getQuantityString(R.plurals.songs_download_started, songsToDownload, songsToDownload), 
+                                Toast.LENGTH_SHORT).show();
+                        }
+                    }
+                    
+                    bind.homeSyncStarredArtistsCard.setVisibility(View.GONE);
+                }
+            });
+        });
+    }
+
+    private void checkIfArtistsNeedSync(List<ArtistID3> artists) {
+        homeViewModel.getAllStarredArtistSongs().observe(getViewLifecycleOwner(), new Observer<List<Child>>() {
+            @Override
+            public void onChanged(List<Child> allSongs) {
+                if (allSongs != null) {
+                    DownloaderManager manager = DownloadUtil.getDownloadTracker(requireContext());
+                    int songsToDownload = 0;
+                    List<String> artistsNeedingSync = new ArrayList<>();
+
+                    for (ArtistID3 artist : artists) {
+                        boolean artistNeedsSync = false;
+                        // Check if any songs from this artist need downloading
+                        for (Child song : allSongs) {
+                            if (song.getArtistId() != null && song.getArtistId().equals(artist.getId()) && 
+                                !manager.isDownloaded(song.getId())) {
+                                songsToDownload++;
+                                artistNeedsSync = true;
+                            }
+                        }
+                        if (artistNeedsSync) {
+                            artistsNeedingSync.add(artist.getName());
+                        }
+                    }
+
+                    if (songsToDownload > 0) {
+                        bind.homeSyncStarredArtistsCard.setVisibility(View.VISIBLE);
+                        String message = getResources().getQuantityString(
+                            R.plurals.home_sync_starred_artists_count, 
+                            artistsNeedingSync.size(), 
+                            artistsNeedingSync.size()
+                        );
+                        bind.homeSyncStarredArtistsToSync.setText(message);
+                    } else {
+                        bind.homeSyncStarredArtistsCard.setVisibility(View.GONE);
+                    }
+                }
+            }
+        });
+    }
+    
     private void initDiscoverSongSlideView() {
         if (homeViewModel.checkHomeSectorVisibility(Constants.HOME_SECTOR_DISCOVERY)) return;
 
@@ -475,8 +600,10 @@ public class HomeTabMusicFragment extends Fragment implements ClickCallback {
 
         bind.topSongsRecyclerView.setHasFixedSize(true);
 
-        topSongAdapter = new SongHorizontalAdapter(this, true, false, null);
+        topSongAdapter = new SongHorizontalAdapter(getViewLifecycleOwner(), this, true, false, null);
         bind.topSongsRecyclerView.setAdapter(topSongAdapter);
+        setTopSongsMediaBrowserListenableFuture();
+        reapplyTopSongsPlayback();
         homeViewModel.getChronologySample(getViewLifecycleOwner()).observe(getViewLifecycleOwner(), chronologies -> {
             if (chronologies == null || chronologies.isEmpty()) {
                 if (bind != null) bind.homeGridTracksSector.setVisibility(View.GONE);
@@ -492,6 +619,7 @@ public class HomeTabMusicFragment extends Fragment implements ClickCallback {
                         .collect(Collectors.toList());
 
                 topSongAdapter.setItems(topSongs);
+                reapplyTopSongsPlayback();
             }
         });
 
@@ -513,8 +641,10 @@ public class HomeTabMusicFragment extends Fragment implements ClickCallback {
 
         bind.starredTracksRecyclerView.setHasFixedSize(true);
 
-        starredSongAdapter = new SongHorizontalAdapter(this, true, false, null);
+        starredSongAdapter = new SongHorizontalAdapter(getViewLifecycleOwner(), this, true, false, null);
         bind.starredTracksRecyclerView.setAdapter(starredSongAdapter);
+        setStarredSongsMediaBrowserListenableFuture();
+        reapplyStarredSongsPlayback();
         homeViewModel.getStarredTracks(getViewLifecycleOwner()).observe(getViewLifecycleOwner(), songs -> {
             if (songs == null) {
                 if (bind != null) bind.starredTracksSector.setVisibility(View.GONE);
@@ -525,6 +655,7 @@ public class HomeTabMusicFragment extends Fragment implements ClickCallback {
                     bind.starredTracksRecyclerView.setLayoutManager(new GridLayoutManager(requireContext(), UIUtil.getSpanCount(songs.size(), 5), GridLayoutManager.HORIZONTAL, false));
 
                 starredSongAdapter.setItems(songs);
+                reapplyStarredSongsPlayback();
             }
         });
 
@@ -954,6 +1085,8 @@ public class HomeTabMusicFragment extends Fragment implements ClickCallback {
             MediaManager.startQueue(mediaBrowserListenableFuture, bundle.getParcelableArrayList(Constants.TRACKS_OBJECT), bundle.getInt(Constants.ITEM_POSITION));
             activity.setBottomSheetInPeek(true);
         }
+        topSongAdapter.notifyDataSetChanged();
+        starredSongAdapter.notifyDataSetChanged();
     }
 
     @Override
@@ -1043,4 +1176,58 @@ public class HomeTabMusicFragment extends Fragment implements ClickCallback {
     public void onShareLongClick(Bundle bundle) {
         Navigation.findNavController(requireView()).navigate(R.id.shareBottomSheetDialog, bundle);
     }
+
+    private void observeStarredSongsPlayback() {
+        playbackViewModel.getCurrentSongId().observe(getViewLifecycleOwner(), id -> {
+            if (starredSongAdapter != null) {
+                Boolean playing = playbackViewModel.getIsPlaying().getValue();
+                starredSongAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+        playbackViewModel.getIsPlaying().observe(getViewLifecycleOwner(), playing -> {
+            if (starredSongAdapter != null) {
+                String id = playbackViewModel.getCurrentSongId().getValue();
+                starredSongAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+    }
+
+    private void observeTopSongsPlayback() {
+        playbackViewModel.getCurrentSongId().observe(getViewLifecycleOwner(), id -> {
+            if (topSongAdapter != null) {
+                Boolean playing = playbackViewModel.getIsPlaying().getValue();
+                topSongAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+        playbackViewModel.getIsPlaying().observe(getViewLifecycleOwner(), playing -> {
+            if (topSongAdapter != null) {
+                String id = playbackViewModel.getCurrentSongId().getValue();
+                topSongAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+    }
+
+    private void reapplyStarredSongsPlayback() {
+        if (starredSongAdapter != null) {
+            String id = playbackViewModel.getCurrentSongId().getValue();
+            Boolean playing = playbackViewModel.getIsPlaying().getValue();
+            starredSongAdapter.setPlaybackState(id, playing != null && playing);
+        }
+    }
+
+    private void reapplyTopSongsPlayback() {
+        if (topSongAdapter != null) {
+            String id = playbackViewModel.getCurrentSongId().getValue();
+            Boolean playing = playbackViewModel.getIsPlaying().getValue();
+            topSongAdapter.setPlaybackState(id, playing != null && playing);
+        }
+    }
+
+    private void setTopSongsMediaBrowserListenableFuture() {
+        topSongAdapter.setMediaBrowserListenableFuture(mediaBrowserListenableFuture);
+    }
+
+    private void setStarredSongsMediaBrowserListenableFuture() {
+        starredSongAdapter.setMediaBrowserListenableFuture(mediaBrowserListenableFuture);
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/PlayerControllerFragment.java

@@ -1,7 +1,11 @@
 package com.cappielloantonio.tempo.ui.fragment;
 
 import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
 import android.os.Bundle;
+import android.os.IBinder;
 import android.text.TextUtils;
 import android.view.LayoutInflater;
 import android.view.View;
@@ -24,11 +28,14 @@ import androidx.media3.common.util.RepeatModeUtil;
 import androidx.media3.common.util.UnstableApi;
 import androidx.media3.session.MediaBrowser;
 import androidx.media3.session.SessionToken;
+import androidx.navigation.NavController;
+import androidx.navigation.NavOptions;
 import androidx.navigation.fragment.NavHostFragment;
 import androidx.viewpager2.widget.ViewPager2;
 
 import com.cappielloantonio.tempo.R;
 import com.cappielloantonio.tempo.databinding.InnerFragmentPlayerControllerBinding;
+import com.cappielloantonio.tempo.service.EqualizerManager;
 import com.cappielloantonio.tempo.service.MediaService;
 import com.cappielloantonio.tempo.ui.activity.MainActivity;
 import com.cappielloantonio.tempo.ui.dialog.RatingDialog;
@@ -68,11 +75,15 @@ public class PlayerControllerFragment extends Fragment {
     private ImageButton playerOpenQueueButton;
     private ImageButton playerTrackInfo;
     private LinearLayout ratingContainer;
+    private ImageButton equalizerButton;
 
     private MainActivity activity;
     private PlayerBottomSheetViewModel playerBottomSheetViewModel;
     private ListenableFuture<MediaBrowser> mediaBrowserListenableFuture;
 
+    private MediaService.LocalBinder mediaServiceBinder;
+    private boolean isServiceBound = false;
+
     @Override
     public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
         activity = (MainActivity) getActivity();
@@ -89,6 +100,7 @@ public class PlayerControllerFragment extends Fragment {
         initMediaListenable();
         initMediaLabelButton();
         initArtistLabelButton();
+        initEqualizerButton();
 
         return view;
     }
@@ -126,6 +138,7 @@ public class PlayerControllerFragment extends Fragment {
         playerTrackInfo = bind.getRoot().findViewById(R.id.player_info_track);
         songRatingBar =  bind.getRoot().findViewById(R.id.song_rating_bar);
         ratingContainer = bind.getRoot().findViewById(R.id.rating_container);
+        equalizerButton = bind.getRoot().findViewById(R.id.player_open_equalizer_button);
         checkAndSetRatingContainerVisibility();
     }
 
@@ -426,6 +439,18 @@ public class PlayerControllerFragment extends Fragment {
         });
     }
 
+    private void initEqualizerButton() {
+        equalizerButton.setOnClickListener(v -> {
+            NavController navController = NavHostFragment.findNavController(this);
+            NavOptions navOptions = new NavOptions.Builder()
+                    .setLaunchSingleTop(true)
+                    .setPopUpTo(R.id.equalizerFragment, true)
+                    .build();
+            navController.navigate(R.id.equalizerFragment, null, navOptions);
+            if (activity != null) activity.collapseBottomSheetDelayed();
+        });
+    }
+
     public void goToControllerPage() {
         playerMediaCoverViewPager.setCurrentItem(0, false);
     }
@@ -461,4 +486,66 @@ public class PlayerControllerFragment extends Fragment {
         mediaBrowser.setPlaybackParameters(new PlaybackParameters(Constants.MEDIA_PLAYBACK_SPEED_100));
         // TODO Resettare lo skip del silenzio
     }
+
+    private final ServiceConnection serviceConnection = new ServiceConnection() {
+        @Override
+        public void onServiceConnected(ComponentName name, IBinder service) {
+            mediaServiceBinder = (MediaService.LocalBinder) service;
+            isServiceBound = true;
+            checkEqualizerBands();
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName name) {
+            mediaServiceBinder = null;
+            isServiceBound = false;
+        }
+    };
+
+    private void bindMediaService() {
+        Intent intent = new Intent(requireActivity(), MediaService.class);
+        intent.setAction(MediaService.ACTION_BIND_EQUALIZER);
+        requireActivity().bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
+        isServiceBound = true;
+    }
+
+    private void checkEqualizerBands() {
+        if (mediaServiceBinder != null) {
+            EqualizerManager eqManager = mediaServiceBinder.getEqualizerManager();
+            short numBands = eqManager.getNumberOfBands();
+
+            if (equalizerButton != null) {
+                if (numBands == 0) {
+                    equalizerButton.setVisibility(View.GONE);
+
+                    ConstraintLayout.LayoutParams params = (ConstraintLayout.LayoutParams) playerOpenQueueButton.getLayoutParams();
+                    params.startToEnd = ConstraintLayout.LayoutParams.UNSET;
+                    params.startToStart = ConstraintLayout.LayoutParams.PARENT_ID;
+                    playerOpenQueueButton.setLayoutParams(params);
+                } else {
+                    equalizerButton.setVisibility(View.VISIBLE);
+
+                    ConstraintLayout.LayoutParams params = (ConstraintLayout.LayoutParams) playerOpenQueueButton.getLayoutParams();
+                    params.startToStart = ConstraintLayout.LayoutParams.UNSET;
+                    params.startToEnd = R.id.player_open_equalizer_button;
+                    playerOpenQueueButton.setLayoutParams(params);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        bindMediaService();
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        if (isServiceBound) {
+            requireActivity().unbindService(serviceConnection);
+            isServiceBound = false;
+        }
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/PlayerCoverFragment.java

@@ -14,6 +14,7 @@ import java.util.ArrayList;
 import androidx.annotation.NonNull;
 import androidx.fragment.app.Fragment;
 import androidx.lifecycle.ViewModelProvider;
+import androidx.media3.common.MediaItem;
 import androidx.media3.common.MediaMetadata;
 import androidx.media3.common.Player;
 import androidx.media3.common.util.UnstableApi;
@@ -31,6 +32,7 @@ import com.cappielloantonio.tempo.util.Constants;
 import com.cappielloantonio.tempo.util.DownloadUtil;
 import com.cappielloantonio.tempo.util.MappingUtil;
 import com.cappielloantonio.tempo.util.Preferences;
+import com.cappielloantonio.tempo.util.ExternalAudioWriter;
 import com.cappielloantonio.tempo.viewmodel.PlayerBottomSheetViewModel;
 import com.cappielloantonio.tempo.subsonic.models.Child;
 import com.google.android.material.snackbar.Snackbar;
@@ -115,10 +117,14 @@ public class PlayerCoverFragment extends Fragment {
         playerBottomSheetViewModel.getLiveMedia().observe(getViewLifecycleOwner(), song -> {
             if (song != null && bind != null) {
                 bind.innerButtonTopLeft.setOnClickListener(view -> {
-                    DownloadUtil.getDownloadTracker(requireContext()).download(
-                            MappingUtil.mapDownload(song),
-                            new Download(song)
-                    );
+                    if (Preferences.getDownloadDirectoryUri() == null) {
+                        DownloadUtil.getDownloadTracker(requireContext()).download(
+                                MappingUtil.mapDownload(song),
+                                new Download(song)
+                        );
+                    } else {
+                        ExternalAudioWriter.downloadToUserDirectory(requireContext(), song);
+                    }
                 });
 
                 bind.innerButtonTopRight.setOnClickListener(view -> {

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/PlayerLyricsFragment.java

@@ -4,15 +4,16 @@ import android.annotation.SuppressLint;
 import android.content.ComponentName;
 import android.os.Bundle;
 import android.os.Handler;
+import android.text.Layout;
 import android.text.Spannable;
 import android.text.SpannableString;
-import android.text.Layout;
+import android.text.TextUtils;
 import android.text.style.ForegroundColorSpan;
-import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.WindowManager;
+import android.widget.Toast;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -29,10 +30,10 @@ import com.cappielloantonio.tempo.service.MediaService;
 import com.cappielloantonio.tempo.subsonic.models.Line;
 import com.cappielloantonio.tempo.subsonic.models.LyricsList;
 import com.cappielloantonio.tempo.util.MusicUtil;
-import com.cappielloantonio.tempo.util.OpenSubsonicExtensionsUtil;
 import com.cappielloantonio.tempo.util.Preferences;
 import com.cappielloantonio.tempo.viewmodel.PlayerBottomSheetViewModel;
 import com.google.common.util.concurrent.ListenableFuture;
+import com.google.android.material.button.MaterialButton;
 import com.google.common.util.concurrent.MoreExecutors;
 
 import java.util.List;
@@ -48,6 +49,9 @@ public class PlayerLyricsFragment extends Fragment {
     private MediaBrowser mediaBrowser;
     private Handler syncLyricsHandler;
     private Runnable syncLyricsRunnable;
+    private String currentLyrics;
+    private LyricsList currentLyricsList;
+    private String currentDescription;
 
     @Override
     public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
@@ -66,6 +70,7 @@ public class PlayerLyricsFragment extends Fragment {
         super.onViewCreated(view, savedInstanceState);
 
         initPanelContent();
+        observeDownloadState();
     }
 
     @Override
@@ -101,12 +106,26 @@ public class PlayerLyricsFragment extends Fragment {
     public void onDestroyView() {
         super.onDestroyView();
         bind = null;
+        currentLyrics = null;
+        currentLyricsList = null;
+        currentDescription = null;
     }
 
     private void initOverlay() {
         bind.syncLyricsTapButton.setOnClickListener(view -> {
             playerBottomSheetViewModel.changeSyncLyricsState();
         });
+
+        bind.downloadLyricsButton.setOnClickListener(view -> {
+            boolean saved = playerBottomSheetViewModel.downloadCurrentLyrics();
+            if (getContext() != null) {
+                Toast.makeText(
+                        requireContext(),
+                        saved ? R.string.player_lyrics_download_success : R.string.player_lyrics_download_failure,
+                        Toast.LENGTH_SHORT
+                ).show();
+            }
+        });
     }
 
     private void initializeBrowser() {
@@ -136,50 +155,91 @@ public class PlayerLyricsFragment extends Fragment {
     }
 
     private void initPanelContent() {
-        if (OpenSubsonicExtensionsUtil.isSongLyricsExtensionAvailable()) {
-            playerBottomSheetViewModel.getLiveLyricsList().observe(getViewLifecycleOwner(), lyricsList -> {
-                setPanelContent(null, lyricsList);
-            });
-        } else {
-            playerBottomSheetViewModel.getLiveLyrics().observe(getViewLifecycleOwner(), lyrics -> {
-                setPanelContent(lyrics, null);
-            });
-        }
+        playerBottomSheetViewModel.getLiveLyrics().observe(getViewLifecycleOwner(), lyrics -> {
+            currentLyrics = lyrics;
+            updatePanelContent();
+        });
+
+        playerBottomSheetViewModel.getLiveLyricsList().observe(getViewLifecycleOwner(), lyricsList -> {
+            currentLyricsList = lyricsList;
+            updatePanelContent();
+        });
+
+        playerBottomSheetViewModel.getLiveDescription().observe(getViewLifecycleOwner(), description -> {
+            currentDescription = description;
+            updatePanelContent();
+        });
     }
 
-    private void setPanelContent(String lyrics, LyricsList lyricsList) {
-        playerBottomSheetViewModel.getLiveDescription().observe(getViewLifecycleOwner(), description -> {
+    private void observeDownloadState() {
+        playerBottomSheetViewModel.getLyricsCachedState().observe(getViewLifecycleOwner(), cached -> {
             if (bind != null) {
-                bind.nowPlayingSongLyricsSrollView.smoothScrollTo(0, 0);
-
-                if (lyrics != null && !lyrics.trim().equals("")) {
-                    bind.nowPlayingSongLyricsTextView.setText(MusicUtil.getReadableLyrics(lyrics));
-                    bind.nowPlayingSongLyricsTextView.setVisibility(View.VISIBLE);
-                    bind.emptyDescriptionImageView.setVisibility(View.GONE);
-                    bind.titleEmptyDescriptionLabel.setVisibility(View.GONE);
-                    bind.syncLyricsTapButton.setVisibility(View.GONE);
-                } else if (lyricsList != null && lyricsList.getStructuredLyrics() != null) {
-                    setSyncLirics(lyricsList);
-                    bind.nowPlayingSongLyricsTextView.setVisibility(View.VISIBLE);
-                    bind.emptyDescriptionImageView.setVisibility(View.GONE);
-                    bind.titleEmptyDescriptionLabel.setVisibility(View.GONE);
-                    bind.syncLyricsTapButton.setVisibility(View.VISIBLE);
-                } else if (description != null && !description.trim().equals("")) {
-                    bind.nowPlayingSongLyricsTextView.setText(MusicUtil.getReadableLyrics(description));
-                    bind.nowPlayingSongLyricsTextView.setVisibility(View.VISIBLE);
-                    bind.emptyDescriptionImageView.setVisibility(View.GONE);
-                    bind.titleEmptyDescriptionLabel.setVisibility(View.GONE);
-                    bind.syncLyricsTapButton.setVisibility(View.GONE);
+                MaterialButton downloadButton = (MaterialButton) bind.downloadLyricsButton;
+                if (cached != null && cached) {
+                    downloadButton.setIconResource(R.drawable.ic_done);
+                    downloadButton.setContentDescription(getString(R.string.player_lyrics_downloaded_content_description));
                 } else {
-                    bind.nowPlayingSongLyricsTextView.setVisibility(View.GONE);
-                    bind.emptyDescriptionImageView.setVisibility(View.VISIBLE);
-                    bind.titleEmptyDescriptionLabel.setVisibility(View.VISIBLE);
-                    bind.syncLyricsTapButton.setVisibility(View.GONE);
+                    downloadButton.setIconResource(R.drawable.ic_download);
+                    downloadButton.setContentDescription(getString(R.string.player_lyrics_download_content_description));
                 }
             }
         });
     }
 
+    private void updatePanelContent() {
+        if (bind == null) {
+            return;
+        }
+
+        bind.nowPlayingSongLyricsSrollView.smoothScrollTo(0, 0);
+
+        if (hasStructuredLyrics(currentLyricsList)) {
+            setSyncLirics(currentLyricsList);
+            bind.nowPlayingSongLyricsTextView.setVisibility(View.VISIBLE);
+            bind.emptyDescriptionImageView.setVisibility(View.GONE);
+            bind.titleEmptyDescriptionLabel.setVisibility(View.GONE);
+            bind.syncLyricsTapButton.setVisibility(View.VISIBLE);
+            bind.downloadLyricsButton.setVisibility(View.VISIBLE);
+            bind.downloadLyricsButton.setEnabled(true);
+        } else if (hasText(currentLyrics)) {
+            bind.nowPlayingSongLyricsTextView.setText(MusicUtil.getReadableLyrics(currentLyrics));
+            bind.nowPlayingSongLyricsTextView.setVisibility(View.VISIBLE);
+            bind.emptyDescriptionImageView.setVisibility(View.GONE);
+            bind.titleEmptyDescriptionLabel.setVisibility(View.GONE);
+            bind.syncLyricsTapButton.setVisibility(View.GONE);
+            bind.downloadLyricsButton.setVisibility(View.VISIBLE);
+            bind.downloadLyricsButton.setEnabled(true);
+        } else if (hasText(currentDescription)) {
+            bind.nowPlayingSongLyricsTextView.setText(MusicUtil.getReadableLyrics(currentDescription));
+            bind.nowPlayingSongLyricsTextView.setVisibility(View.VISIBLE);
+            bind.emptyDescriptionImageView.setVisibility(View.GONE);
+            bind.titleEmptyDescriptionLabel.setVisibility(View.GONE);
+            bind.syncLyricsTapButton.setVisibility(View.GONE);
+            bind.downloadLyricsButton.setVisibility(View.GONE);
+            bind.downloadLyricsButton.setEnabled(false);
+        } else {
+            bind.nowPlayingSongLyricsTextView.setVisibility(View.GONE);
+            bind.emptyDescriptionImageView.setVisibility(View.VISIBLE);
+            bind.titleEmptyDescriptionLabel.setVisibility(View.VISIBLE);
+            bind.syncLyricsTapButton.setVisibility(View.GONE);
+            bind.downloadLyricsButton.setVisibility(View.GONE);
+            bind.downloadLyricsButton.setEnabled(false);
+        }
+    }
+
+    private boolean hasText(String value) {
+        return value != null && !value.trim().isEmpty();
+    }
+
+    private boolean hasStructuredLyrics(LyricsList lyricsList) {
+        return lyricsList != null
+                && lyricsList.getStructuredLyrics() != null
+                && !lyricsList.getStructuredLyrics().isEmpty()
+                && lyricsList.getStructuredLyrics().get(0) != null
+                && lyricsList.getStructuredLyrics().get(0).getLine() != null
+                && !lyricsList.getStructuredLyrics().get(0).getLine().isEmpty();
+    }
+
     @SuppressLint("DefaultLocale")
     private void setSyncLirics(LyricsList lyricsList) {
         if (lyricsList.getStructuredLyrics() != null && !lyricsList.getStructuredLyrics().isEmpty() && lyricsList.getStructuredLyrics().get(0).getLine() != null) {
@@ -198,28 +258,28 @@ public class PlayerLyricsFragment extends Fragment {
 
     private void defineProgressHandler() {
         playerBottomSheetViewModel.getLiveLyricsList().observe(getViewLifecycleOwner(), lyricsList -> {
-            if (lyricsList != null) {
-
-                if (lyricsList.getStructuredLyrics() != null && lyricsList.getStructuredLyrics().get(0) != null && !lyricsList.getStructuredLyrics().get(0).getSynced()) {
-                    releaseHandler();
-                    return;
-                }
-
-                syncLyricsHandler = new Handler();
-                syncLyricsRunnable = () -> {
-                    if (syncLyricsHandler != null) {
-                        if (bind != null) {
-                            displaySyncedLyrics();
-                        }
-
-                        syncLyricsHandler.postDelayed(syncLyricsRunnable, 250);
-                    }
-                };
-
-                syncLyricsHandler.postDelayed(syncLyricsRunnable, 250);
-            } else {
+            if (!hasStructuredLyrics(lyricsList)) {
                 releaseHandler();
+                return;
             }
+
+            if (!lyricsList.getStructuredLyrics().get(0).getSynced()) {
+                releaseHandler();
+                return;
+            }
+
+            syncLyricsHandler = new Handler();
+            syncLyricsRunnable = () -> {
+                if (syncLyricsHandler != null) {
+                    if (bind != null) {
+                        displaySyncedLyrics();
+                    }
+
+                    syncLyricsHandler.postDelayed(syncLyricsRunnable, 250);
+                }
+            };
+
+            syncLyricsHandler.postDelayed(syncLyricsRunnable, 250);
         });
     }
 
@@ -227,7 +287,7 @@ public class PlayerLyricsFragment extends Fragment {
         LyricsList lyricsList = playerBottomSheetViewModel.getLiveLyricsList().getValue();
         int timestamp = (int) (mediaBrowser.getCurrentPosition());
 
-        if (lyricsList != null && lyricsList.getStructuredLyrics() != null && !lyricsList.getStructuredLyrics().isEmpty() && lyricsList.getStructuredLyrics().get(0).getLine() != null) {
+        if (hasStructuredLyrics(lyricsList)) {
             StringBuilder lyricsBuilder = new StringBuilder();
             List<Line> lines = lyricsList.getStructuredLyrics().get(0).getLine();
 

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/PlayerQueueFragment.java

@@ -23,6 +23,7 @@ import com.cappielloantonio.tempo.service.MediaService;
 import com.cappielloantonio.tempo.subsonic.models.Child;
 import com.cappielloantonio.tempo.ui.adapter.PlayerSongQueueAdapter;
 import com.cappielloantonio.tempo.util.Constants;
+import com.cappielloantonio.tempo.viewmodel.PlaybackViewModel;
 import com.cappielloantonio.tempo.viewmodel.PlayerBottomSheetViewModel;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.MoreExecutors;
@@ -38,6 +39,7 @@ public class PlayerQueueFragment extends Fragment implements ClickCallback {
     private InnerFragmentPlayerQueueBinding bind;
 
     private PlayerBottomSheetViewModel playerBottomSheetViewModel;
+    private PlaybackViewModel playbackViewModel;
     private ListenableFuture<MediaBrowser> mediaBrowserListenableFuture;
 
     private PlayerSongQueueAdapter playerSongQueueAdapter;
@@ -48,6 +50,7 @@ public class PlayerQueueFragment extends Fragment implements ClickCallback {
         View view = bind.getRoot();
 
         playerBottomSheetViewModel = new ViewModelProvider(requireActivity()).get(PlayerBottomSheetViewModel.class);
+        playbackViewModel = new ViewModelProvider(requireActivity()).get(PlaybackViewModel.class);
 
         initQueueRecyclerView();
 
@@ -59,6 +62,9 @@ public class PlayerQueueFragment extends Fragment implements ClickCallback {
         super.onStart();
         initializeBrowser();
         bindMediaController();
+
+        MediaManager.registerPlaybackObserver(mediaBrowserListenableFuture, playbackViewModel);
+        observePlayback();
     }
 
     @Override
@@ -110,9 +116,12 @@ public class PlayerQueueFragment extends Fragment implements ClickCallback {
 
         playerSongQueueAdapter = new PlayerSongQueueAdapter(this);
         bind.playerQueueRecyclerView.setAdapter(playerSongQueueAdapter);
+        reapplyPlayback();
+
         playerBottomSheetViewModel.getQueueSong().observe(getViewLifecycleOwner(), queue -> {
             if (queue != null) {
                 playerSongQueueAdapter.setItems(queue.stream().map(item -> (Child) item).collect(Collectors.toList()));
+                reapplyPlayback();
             }
         });
 
@@ -216,4 +225,27 @@ public class PlayerQueueFragment extends Fragment implements ClickCallback {
     public void onMediaClick(Bundle bundle) {
         MediaManager.startQueue(mediaBrowserListenableFuture, bundle.getParcelableArrayList(Constants.TRACKS_OBJECT), bundle.getInt(Constants.ITEM_POSITION));
     }
+
+    private void observePlayback() {
+        playbackViewModel.getCurrentSongId().observe(getViewLifecycleOwner(), id -> {
+            if (playerSongQueueAdapter != null) {
+                Boolean playing = playbackViewModel.getIsPlaying().getValue();
+                playerSongQueueAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+        playbackViewModel.getIsPlaying().observe(getViewLifecycleOwner(), playing -> {
+            if (playerSongQueueAdapter != null) {
+                String id = playbackViewModel.getCurrentSongId().getValue();
+                playerSongQueueAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+    }
+
+    private void reapplyPlayback() {
+        if (playerSongQueueAdapter != null) {
+            String id = playbackViewModel.getCurrentSongId().getValue();
+            Boolean playing = playbackViewModel.getIsPlaying().getValue();
+            playerSongQueueAdapter.setPlaybackState(id, playing != null && playing);
+        }
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/PlaylistPageFragment.java

@@ -37,6 +37,9 @@ import com.cappielloantonio.tempo.util.Constants;
 import com.cappielloantonio.tempo.util.DownloadUtil;
 import com.cappielloantonio.tempo.util.MappingUtil;
 import com.cappielloantonio.tempo.util.MusicUtil;
+import com.cappielloantonio.tempo.util.ExternalAudioWriter;
+import com.cappielloantonio.tempo.util.Preferences;
+import com.cappielloantonio.tempo.viewmodel.PlaybackViewModel;
 import com.cappielloantonio.tempo.viewmodel.PlaylistPageViewModel;
 import com.google.common.util.concurrent.ListenableFuture;
 
@@ -49,6 +52,7 @@ public class PlaylistPageFragment extends Fragment implements ClickCallback {
     private FragmentPlaylistPageBinding bind;
     private MainActivity activity;
     private PlaylistPageViewModel playlistPageViewModel;
+    private PlaybackViewModel playbackViewModel;
 
     private SongHorizontalAdapter songHorizontalAdapter;
 
@@ -94,6 +98,7 @@ public class PlaylistPageFragment extends Fragment implements ClickCallback {
         bind = FragmentPlaylistPageBinding.inflate(inflater, container, false);
         View view = bind.getRoot();
         playlistPageViewModel = new ViewModelProvider(requireActivity()).get(PlaylistPageViewModel.class);
+        playbackViewModel = new ViewModelProvider(requireActivity()).get(PlaybackViewModel.class);
 
         init();
         initAppBar();
@@ -109,6 +114,15 @@ public class PlaylistPageFragment extends Fragment implements ClickCallback {
         super.onStart();
 
         initializeMediaBrowser();
+
+        MediaManager.registerPlaybackObserver(mediaBrowserListenableFuture, playbackViewModel);
+        observePlayback();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        if (songHorizontalAdapter != null) setMediaBrowserListenableFuture();
     }
 
     @Override
@@ -128,7 +142,8 @@ public class PlaylistPageFragment extends Fragment implements ClickCallback {
         if (item.getItemId() == R.id.action_download_playlist) {
             playlistPageViewModel.getPlaylistSongLiveList().observe(getViewLifecycleOwner(), songs -> {
                 if (isVisible() && getActivity() != null) {
-                    DownloadUtil.getDownloadTracker(requireContext()).download(
+                    if (Preferences.getDownloadDirectoryUri() == null) {
+                        DownloadUtil.getDownloadTracker(requireContext()).download(
                             MappingUtil.mapDownloads(songs),
                             songs.stream().map(child -> {
                                 Download toDownload = new Download(child);
@@ -136,7 +151,10 @@ public class PlaylistPageFragment extends Fragment implements ClickCallback {
                                 toDownload.setPlaylistName(playlistPageViewModel.getPlaylist().getName());
                                 return toDownload;
                             }).collect(Collectors.toList())
-                    );
+                        );
+                    } else {
+                        songs.forEach(child -> ExternalAudioWriter.downloadToUserDirectory(requireContext(), child));
+                    }
                 }
             });
             return true;
@@ -246,10 +264,15 @@ public class PlaylistPageFragment extends Fragment implements ClickCallback {
         bind.songRecyclerView.setLayoutManager(new LinearLayoutManager(requireContext()));
         bind.songRecyclerView.setHasFixedSize(true);
 
-        songHorizontalAdapter = new SongHorizontalAdapter(this, true, false, null);
+        songHorizontalAdapter = new SongHorizontalAdapter(getViewLifecycleOwner(), this, true, false, null);
         bind.songRecyclerView.setAdapter(songHorizontalAdapter);
+        setMediaBrowserListenableFuture();
+        reapplyPlayback();
 
-        playlistPageViewModel.getPlaylistSongLiveList().observe(getViewLifecycleOwner(), songs -> songHorizontalAdapter.setItems(songs));
+        playlistPageViewModel.getPlaylistSongLiveList().observe(getViewLifecycleOwner(), songs -> {
+            songHorizontalAdapter.setItems(songs);
+            reapplyPlayback();
+        });
     }
 
     private void initializeMediaBrowser() {
@@ -270,4 +293,31 @@ public class PlaylistPageFragment extends Fragment implements ClickCallback {
     public void onMediaLongClick(Bundle bundle) {
         Navigation.findNavController(requireView()).navigate(R.id.songBottomSheetDialog, bundle);
     }
+
+    private void observePlayback() {
+        playbackViewModel.getCurrentSongId().observe(getViewLifecycleOwner(), id -> {
+            if (songHorizontalAdapter != null) {
+                Boolean playing = playbackViewModel.getIsPlaying().getValue();
+                songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+        playbackViewModel.getIsPlaying().observe(getViewLifecycleOwner(), playing -> {
+            if (songHorizontalAdapter != null) {
+                String id = playbackViewModel.getCurrentSongId().getValue();
+                songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+    }
+
+    private void reapplyPlayback() {
+        if (songHorizontalAdapter != null) {
+            String id = playbackViewModel.getCurrentSongId().getValue();
+            Boolean playing = playbackViewModel.getIsPlaying().getValue();
+            songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+        }
+    }
+
+    private void setMediaBrowserListenableFuture() {
+        songHorizontalAdapter.setMediaBrowserListenableFuture(mediaBrowserListenableFuture);
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/SearchFragment.java

@@ -4,14 +4,11 @@ import android.content.ComponentName;
 import android.os.Bundle;
 import android.text.Editable;
 import android.text.TextWatcher;
-import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
-import android.view.inputmethod.EditorInfo;
 import android.widget.ImageView;
 import android.widget.TextView;
-import android.widget.Toast;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -34,6 +31,7 @@ import com.cappielloantonio.tempo.ui.adapter.AlbumAdapter;
 import com.cappielloantonio.tempo.ui.adapter.ArtistAdapter;
 import com.cappielloantonio.tempo.ui.adapter.SongHorizontalAdapter;
 import com.cappielloantonio.tempo.util.Constants;
+import com.cappielloantonio.tempo.viewmodel.PlaybackViewModel;
 import com.cappielloantonio.tempo.viewmodel.SearchViewModel;
 import com.google.common.util.concurrent.ListenableFuture;
 
@@ -46,6 +44,7 @@ public class SearchFragment extends Fragment implements ClickCallback {
     private FragmentSearchBinding bind;
     private MainActivity activity;
     private SearchViewModel searchViewModel;
+    private PlaybackViewModel playbackViewModel;
 
     private ArtistAdapter artistAdapter;
     private AlbumAdapter albumAdapter;
@@ -61,6 +60,7 @@ public class SearchFragment extends Fragment implements ClickCallback {
         bind = FragmentSearchBinding.inflate(inflater, container, false);
         View view = bind.getRoot();
         searchViewModel = new ViewModelProvider(requireActivity()).get(SearchViewModel.class);
+        playbackViewModel = new ViewModelProvider(requireActivity()).get(PlaybackViewModel.class);
 
         initSearchResultView();
         initSearchView();
@@ -73,6 +73,15 @@ public class SearchFragment extends Fragment implements ClickCallback {
     public void onStart() {
         super.onStart();
         initializeMediaBrowser();
+
+        MediaManager.registerPlaybackObserver(mediaBrowserListenableFuture, playbackViewModel);
+        observePlayback();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        if (songHorizontalAdapter != null) setMediaBrowserListenableFuture();
     }
 
     @Override
@@ -112,7 +121,10 @@ public class SearchFragment extends Fragment implements ClickCallback {
         bind.searchResultTracksRecyclerView.setLayoutManager(new LinearLayoutManager(requireContext()));
         bind.searchResultTracksRecyclerView.setHasFixedSize(true);
 
-        songHorizontalAdapter = new SongHorizontalAdapter(this, true, false, null);
+        songHorizontalAdapter = new SongHorizontalAdapter(getViewLifecycleOwner(), this, true, false, null);
+        setMediaBrowserListenableFuture();
+        reapplyPlayback();
+
         bind.searchResultTracksRecyclerView.setAdapter(songHorizontalAdapter);
     }
 
@@ -242,7 +254,7 @@ public class SearchFragment extends Fragment implements ClickCallback {
     }
 
     private boolean isQueryValid(String query) {
-        return !query.equals("") && query.trim().length() > 2;
+        return !query.equals("") && query.trim().length() > 1;
     }
 
     private void inputFocus() {
@@ -260,6 +272,7 @@ public class SearchFragment extends Fragment implements ClickCallback {
     @Override
     public void onMediaClick(Bundle bundle) {
         MediaManager.startQueue(mediaBrowserListenableFuture, bundle.getParcelableArrayList(Constants.TRACKS_OBJECT), bundle.getInt(Constants.ITEM_POSITION));
+        songHorizontalAdapter.notifyDataSetChanged();
         activity.setBottomSheetInPeek(true);
     }
 
@@ -287,4 +300,31 @@ public class SearchFragment extends Fragment implements ClickCallback {
     public void onArtistLongClick(Bundle bundle) {
         Navigation.findNavController(requireView()).navigate(R.id.artistBottomSheetDialog, bundle);
     }
+
+    private void observePlayback() {
+        playbackViewModel.getCurrentSongId().observe(getViewLifecycleOwner(), id -> {
+            if (songHorizontalAdapter != null) {
+                Boolean playing = playbackViewModel.getIsPlaying().getValue();
+                songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+        playbackViewModel.getIsPlaying().observe(getViewLifecycleOwner(), playing -> {
+            if (songHorizontalAdapter != null) {
+                String id = playbackViewModel.getCurrentSongId().getValue();
+                songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+    }
+
+    private void reapplyPlayback() {
+        if (songHorizontalAdapter != null) {
+            String id = playbackViewModel.getCurrentSongId().getValue();
+            Boolean playing = playbackViewModel.getIsPlaying().getValue();
+            songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+        }
+    }
+
+    private void setMediaBrowserListenableFuture() {
+        songHorizontalAdapter.setMediaBrowserListenableFuture(mediaBrowserListenableFuture);
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/SettingsFragment.java

@@ -1,13 +1,19 @@
 package com.cappielloantonio.tempo.ui.fragment;
 
+import android.app.Activity;
+import android.content.Context;
+import android.content.ComponentName;
 import android.content.Intent;
+import android.content.ServiceConnection;
 import android.media.audiofx.AudioEffect;
+import android.net.Uri;
 import android.os.Bundle;
-import android.os.Handler;
+import android.os.IBinder;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.WindowManager;
+import android.widget.Toast;
 
 import androidx.activity.result.ActivityResultLauncher;
 import androidx.activity.result.contract.ActivityResultContracts;
@@ -18,6 +24,9 @@ import androidx.appcompat.app.AppCompatDelegate;
 import androidx.core.os.LocaleListCompat;
 import androidx.lifecycle.ViewModelProvider;
 import androidx.media3.common.util.UnstableApi;
+import androidx.navigation.NavController;
+import androidx.navigation.NavOptions;
+import androidx.navigation.fragment.NavHostFragment;
 import androidx.preference.ListPreference;
 import androidx.preference.Preference;
 import androidx.preference.PreferenceFragmentCompat;
@@ -28,15 +37,19 @@ import com.cappielloantonio.tempo.R;
 import com.cappielloantonio.tempo.helper.ThemeHelper;
 import com.cappielloantonio.tempo.interfaces.DialogClickCallback;
 import com.cappielloantonio.tempo.interfaces.ScanCallback;
+import com.cappielloantonio.tempo.service.EqualizerManager;
+import com.cappielloantonio.tempo.service.MediaService;
 import com.cappielloantonio.tempo.ui.activity.MainActivity;
 import com.cappielloantonio.tempo.ui.dialog.DeleteDownloadStorageDialog;
 import com.cappielloantonio.tempo.ui.dialog.DownloadStorageDialog;
 import com.cappielloantonio.tempo.ui.dialog.StarredSyncDialog;
 import com.cappielloantonio.tempo.ui.dialog.StarredAlbumSyncDialog;
+import com.cappielloantonio.tempo.ui.dialog.StarredArtistSyncDialog;
 import com.cappielloantonio.tempo.ui.dialog.StreamingCacheStorageDialog;
 import com.cappielloantonio.tempo.util.DownloadUtil;
 import com.cappielloantonio.tempo.util.Preferences;
 import com.cappielloantonio.tempo.util.UIUtil;
+import com.cappielloantonio.tempo.util.ExternalAudioReader;
 import com.cappielloantonio.tempo.viewmodel.SettingViewModel;
 
 import java.util.Locale;
@@ -49,15 +62,41 @@ public class SettingsFragment extends PreferenceFragmentCompat {
     private MainActivity activity;
     private SettingViewModel settingViewModel;
 
-    private ActivityResultLauncher<Intent> someActivityResultLauncher;
+    private ActivityResultLauncher<Intent> equalizerResultLauncher;
+    private ActivityResultLauncher<Intent> directoryPickerLauncher;
+
+    private MediaService.LocalBinder mediaServiceBinder;
+    private boolean isServiceBound = false;
 
     @Override
     public void onCreate(@Nullable Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
-        someActivityResultLauncher = registerForActivityResult(
+        equalizerResultLauncher = registerForActivityResult(
+                new ActivityResultContracts.StartActivityForResult(),
+                result -> {}
+        );
+
+        directoryPickerLauncher = registerForActivityResult(
                 new ActivityResultContracts.StartActivityForResult(),
                 result -> {
+                    if (result.getResultCode() == Activity.RESULT_OK) {
+                        Intent data = result.getData();
+                        if (data != null) {
+                            Uri uri = data.getData();
+                            if (uri != null) {
+                                requireContext().getContentResolver().takePersistableUriPermission(
+                                    uri,
+                                    Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION
+                                );
+
+                                Preferences.setDownloadDirectoryUri(uri.toString());
+                                ExternalAudioReader.refreshCache();
+                                Toast.makeText(requireContext(), "Download folder set.", Toast.LENGTH_SHORT).show();
+                                checkDownloadDirectory();
+                            }
+                        }
+                    }
                 });
     }
 
@@ -86,9 +125,10 @@ public class SettingsFragment extends PreferenceFragmentCompat {
     public void onResume() {
         super.onResume();
 
-        checkEqualizer();
+        checkSystemEqualizer();
         checkCacheStorage();
         checkStorage();
+        checkDownloadDirectory();
 
         setStreamingCacheSize();
         setAppLanguage();
@@ -98,10 +138,17 @@ public class SettingsFragment extends PreferenceFragmentCompat {
         actionScan();
         actionSyncStarredAlbums();
         actionSyncStarredTracks();
+        actionSyncStarredArtists();
         actionChangeStreamingCacheStorage();
         actionChangeDownloadStorage();
+        actionSetDownloadDirectory();
         actionDeleteDownloadStorage();
         actionKeepScreenOn();
+        actionAutoDownloadLyrics();
+        actionMiniPlayerHeart();
+
+        bindMediaService();
+        actionAppEqualizer();
     }
 
     @Override
@@ -124,8 +171,8 @@ public class SettingsFragment extends PreferenceFragmentCompat {
         }
     }
 
-    private void checkEqualizer() {
-        Preference equalizer = findPreference("equalizer");
+    private void checkSystemEqualizer() {
+        Preference equalizer = findPreference("system_equalizer");
 
         if (equalizer == null) return;
 
@@ -133,7 +180,7 @@ public class SettingsFragment extends PreferenceFragmentCompat {
 
         if ((intent.resolveActivity(requireActivity().getPackageManager()) != null)) {
             equalizer.setOnPreferenceClickListener(preference -> {
-                someActivityResultLauncher.launch(intent);
+                equalizerResultLauncher.launch(intent);
                 return true;
             });
         } else {
@@ -150,7 +197,7 @@ public class SettingsFragment extends PreferenceFragmentCompat {
             if (requireContext().getExternalFilesDirs(null)[1] == null) {
                 storage.setVisible(false);
             } else {
-                storage.setSummary(Preferences.getDownloadStoragePreference() == 0 ? R.string.download_storage_internal_dialog_negative_button : R.string.download_storage_external_dialog_positive_button);
+                storage.setSummary(Preferences.getStreamingCacheStoragePreference() == 0 ? R.string.download_storage_internal_dialog_negative_button : R.string.download_storage_external_dialog_positive_button);
             }
         } catch (Exception exception) {
             storage.setVisible(false);
@@ -166,13 +213,46 @@ public class SettingsFragment extends PreferenceFragmentCompat {
             if (requireContext().getExternalFilesDirs(null)[1] == null) {
                 storage.setVisible(false);
             } else {
-                storage.setSummary(Preferences.getDownloadStoragePreference() == 0 ? R.string.download_storage_internal_dialog_negative_button : R.string.download_storage_external_dialog_positive_button);
+                int pref = Preferences.getDownloadStoragePreference();
+                if (pref == 0) {
+                    storage.setSummary(R.string.download_storage_internal_dialog_negative_button);
+                } else if (pref == 1) {
+                    storage.setSummary(R.string.download_storage_external_dialog_positive_button);
+                } else {
+                    storage.setSummary(R.string.download_storage_directory_dialog_neutral_button);
+                }
             }
         } catch (Exception exception) {
             storage.setVisible(false);
         }
     }
 
+    private void checkDownloadDirectory() {
+        Preference storage = findPreference("download_storage");
+        Preference directory = findPreference("set_download_directory");
+
+        if (directory == null) return;
+
+        String current = Preferences.getDownloadDirectoryUri();
+        if (current != null) {
+            if (storage != null) storage.setVisible(false);
+            directory.setVisible(true);
+            directory.setIcon(R.drawable.ic_close);
+            directory.setTitle("Clear download folder");
+            directory.setSummary(current);
+        } else {
+            if (storage != null) storage.setVisible(true);
+            if (Preferences.getDownloadStoragePreference() == 2) {
+                directory.setVisible(true);
+                directory.setIcon(R.drawable.ic_folder);
+                directory.setTitle("Set download folder");
+                directory.setSummary("Choose a folder for downloaded music files");
+            } else {
+                directory.setVisible(false);
+            }
+        }
+    }
+
     private void setStreamingCacheSize() {
         ListPreference streamingCachePreference = findPreference("streaming_cache_size");
 
@@ -281,7 +361,21 @@ public class SettingsFragment extends PreferenceFragmentCompat {
             return true;
         });
     }
-    
+
+    private void actionSyncStarredArtists() {
+        findPreference("sync_starred_artists_for_offline_use").setOnPreferenceChangeListener((preference, newValue) -> {
+            if (newValue instanceof Boolean) {
+                if ((Boolean) newValue) {
+                    StarredArtistSyncDialog dialog = new StarredArtistSyncDialog(() -> {
+                        ((SwitchPreference)preference).setChecked(false);
+                    });
+                    dialog.show(activity.getSupportFragmentManager(), null);
+                }
+            }
+            return true;
+        });
+    }
+
     private void actionChangeStreamingCacheStorage() {
         findPreference("streaming_cache_storage").setOnPreferenceClickListener(preference -> {
             StreamingCacheStorageDialog dialog = new StreamingCacheStorageDialog(new DialogClickCallback() {
@@ -306,11 +400,19 @@ public class SettingsFragment extends PreferenceFragmentCompat {
                 @Override
                 public void onPositiveClick() {
                     findPreference("download_storage").setSummary(R.string.download_storage_external_dialog_positive_button);
+                    checkDownloadDirectory();
                 }
 
                 @Override
                 public void onNegativeClick() {
                     findPreference("download_storage").setSummary(R.string.download_storage_internal_dialog_negative_button);
+                    checkDownloadDirectory();
+                }
+
+                @Override
+                public void onNeutralClick() {
+                    findPreference("download_storage").setSummary(R.string.download_storage_directory_dialog_neutral_button);
+                    checkDownloadDirectory();
                 }
             });
             dialog.show(activity.getSupportFragmentManager(), null);
@@ -318,6 +420,31 @@ public class SettingsFragment extends PreferenceFragmentCompat {
         });
     }
 
+    private void actionSetDownloadDirectory() {
+        Preference pref = findPreference("set_download_directory");
+        if (pref != null) {
+            pref.setOnPreferenceClickListener(preference -> {
+                String current = Preferences.getDownloadDirectoryUri();
+
+                if (current != null) {
+                    Preferences.setDownloadDirectoryUri(null);
+                    Preferences.setDownloadStoragePreference(0);
+                    ExternalAudioReader.refreshCache();
+                    Toast.makeText(requireContext(), "Download folder cleared.", Toast.LENGTH_SHORT).show();
+                    checkStorage();
+                    checkDownloadDirectory();
+                } else {
+                    Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
+                    intent.addFlags(Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION
+                        | Intent.FLAG_GRANT_READ_URI_PERMISSION
+                        | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
+                    directoryPickerLauncher.launch(intent);
+                }
+                return true;
+            });
+        }
+    }
+
     private void actionDeleteDownloadStorage() {
         findPreference("delete_download_storage").setOnPreferenceClickListener(preference -> {
             DeleteDownloadStorageDialog dialog = new DeleteDownloadStorageDialog();
@@ -326,6 +453,36 @@ public class SettingsFragment extends PreferenceFragmentCompat {
         });
     }
 
+    private void actionMiniPlayerHeart() {
+        SwitchPreference preference = findPreference("mini_shuffle_button_visibility");
+        if (preference == null) {
+            return;
+        }
+
+        preference.setChecked(Preferences.showShuffleInsteadOfHeart());
+        preference.setOnPreferenceChangeListener((pref, newValue) -> {
+            if (newValue instanceof Boolean) {
+                Preferences.setShuffleInsteadOfHeart((Boolean) newValue);
+            }
+            return true;
+        });
+    }
+
+    private void actionAutoDownloadLyrics() {
+        SwitchPreference preference = findPreference("auto_download_lyrics");
+        if (preference == null) {
+            return;
+        }
+
+        preference.setChecked(Preferences.isAutoDownloadLyricsEnabled());
+        preference.setOnPreferenceChangeListener((pref, newValue) -> {
+            if (newValue instanceof Boolean) {
+                Preferences.setAutoDownloadLyricsEnabled((Boolean) newValue);
+            }
+            return true;
+        });
+    }
+
     private void getScanStatus() {
         settingViewModel.getScanStatus(new ScanCallback() {
             @Override
@@ -353,4 +510,63 @@ public class SettingsFragment extends PreferenceFragmentCompat {
             return true;
         });
     }
+
+    private final ServiceConnection serviceConnection = new ServiceConnection() {
+        @Override
+        public void onServiceConnected(ComponentName name, IBinder service) {
+            mediaServiceBinder = (MediaService.LocalBinder) service;
+            isServiceBound = true;
+            checkEqualizerBands();
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName name) {
+            mediaServiceBinder = null;
+            isServiceBound = false;
+        }
+    };
+
+    private void bindMediaService() {
+        Intent intent = new Intent(requireActivity(), MediaService.class);
+        intent.setAction(MediaService.ACTION_BIND_EQUALIZER);
+        requireActivity().bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
+        isServiceBound = true;
+    }
+
+    private void checkEqualizerBands() {
+        if (mediaServiceBinder != null) {
+            EqualizerManager eqManager = mediaServiceBinder.getEqualizerManager();
+            short numBands = eqManager.getNumberOfBands();
+            Preference appEqualizer = findPreference("app_equalizer");
+            if (appEqualizer != null) {
+                appEqualizer.setVisible(numBands > 0);
+            }
+        }
+    }
+
+    private void actionAppEqualizer() {
+        Preference appEqualizer = findPreference("app_equalizer");
+        if (appEqualizer != null) {
+            appEqualizer.setOnPreferenceClickListener(preference -> {
+                NavController navController = NavHostFragment.findNavController(this);
+                NavOptions navOptions = new NavOptions.Builder()
+                        .setLaunchSingleTop(true)
+                        .setPopUpTo(R.id.equalizerFragment, true)
+                        .build();
+                activity.setBottomNavigationBarVisibility(true);
+                activity.setBottomSheetVisibility(true);
+                navController.navigate(R.id.equalizerFragment, null, navOptions);
+                return true;
+            });
+        }
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        if (isServiceBound) {
+            requireActivity().unbindService(serviceConnection);
+            isServiceBound = false;
+        }
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/SongListPageFragment.java

@@ -36,6 +36,7 @@ import com.cappielloantonio.tempo.subsonic.models.Child;
 import com.cappielloantonio.tempo.ui.activity.MainActivity;
 import com.cappielloantonio.tempo.ui.adapter.SongHorizontalAdapter;
 import com.cappielloantonio.tempo.util.Constants;
+import com.cappielloantonio.tempo.viewmodel.PlaybackViewModel;
 import com.cappielloantonio.tempo.viewmodel.SongListPageViewModel;
 import com.google.common.util.concurrent.ListenableFuture;
 
@@ -49,6 +50,7 @@ public class SongListPageFragment extends Fragment implements ClickCallback {
     private FragmentSongListPageBinding bind;
     private MainActivity activity;
     private SongListPageViewModel songListPageViewModel;
+    private PlaybackViewModel playbackViewModel;
 
     private SongHorizontalAdapter songHorizontalAdapter;
 
@@ -69,6 +71,7 @@ public class SongListPageFragment extends Fragment implements ClickCallback {
         bind = FragmentSongListPageBinding.inflate(inflater, container, false);
         View view = bind.getRoot();
         songListPageViewModel = new ViewModelProvider(requireActivity()).get(SongListPageViewModel.class);
+        playbackViewModel = new ViewModelProvider(requireActivity()).get(PlaybackViewModel.class);
 
         init();
         initAppBar();
@@ -82,6 +85,15 @@ public class SongListPageFragment extends Fragment implements ClickCallback {
     public void onStart() {
         super.onStart();
         initializeMediaBrowser();
+
+        MediaManager.registerPlaybackObserver(mediaBrowserListenableFuture, playbackViewModel);
+        observePlayback();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        setMediaBrowserListenableFuture();
     }
 
     @Override
@@ -189,11 +201,14 @@ public class SongListPageFragment extends Fragment implements ClickCallback {
         bind.songListRecyclerView.setLayoutManager(new LinearLayoutManager(requireContext()));
         bind.songListRecyclerView.setHasFixedSize(true);
 
-        songHorizontalAdapter = new SongHorizontalAdapter(this, true, false, null);
+        songHorizontalAdapter = new SongHorizontalAdapter(getViewLifecycleOwner(), this, true, false, null);
         bind.songListRecyclerView.setAdapter(songHorizontalAdapter);
+        setMediaBrowserListenableFuture();
+        reapplyPlayback();
         songListPageViewModel.getSongList().observe(getViewLifecycleOwner(), songs -> {
             isLoading = false;
             songHorizontalAdapter.setItems(songs);
+            reapplyPlayback();
             setSongListPageSubtitle(songs);
         });
 
@@ -325,4 +340,31 @@ public class SongListPageFragment extends Fragment implements ClickCallback {
     public void onMediaLongClick(Bundle bundle) {
         Navigation.findNavController(requireView()).navigate(R.id.songBottomSheetDialog, bundle);
     }
+
+    private void observePlayback() {
+        playbackViewModel.getCurrentSongId().observe(getViewLifecycleOwner(), id -> {
+            if (songHorizontalAdapter != null) {
+                Boolean playing = playbackViewModel.getIsPlaying().getValue();
+                songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+        playbackViewModel.getIsPlaying().observe(getViewLifecycleOwner(), playing -> {
+            if (songHorizontalAdapter != null) {
+                String id = playbackViewModel.getCurrentSongId().getValue();
+                songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+            }
+        });
+    }
+
+    private void reapplyPlayback() {
+        if (songHorizontalAdapter != null) {
+            String id = playbackViewModel.getCurrentSongId().getValue();
+            Boolean playing = playbackViewModel.getIsPlaying().getValue();
+            songHorizontalAdapter.setPlaybackState(id, playing != null && playing);
+        }
+    }
+
+    private void setMediaBrowserListenableFuture() {
+        songHorizontalAdapter.setMediaBrowserListenableFuture(mediaBrowserListenableFuture);
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/bottomsheetdialog/AlbumBottomSheetDialog.java

@@ -13,6 +13,7 @@ import android.widget.TextView;
 import android.widget.Toast;
 import android.widget.ToggleButton;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.lifecycle.ViewModelProvider;
 import androidx.media3.common.MediaItem;
@@ -37,6 +38,8 @@ import com.cappielloantonio.tempo.util.DownloadUtil;
 import com.cappielloantonio.tempo.util.MappingUtil;
 import com.cappielloantonio.tempo.util.MusicUtil;
 import com.cappielloantonio.tempo.util.Preferences;
+import com.cappielloantonio.tempo.util.ExternalAudioWriter;
+import com.cappielloantonio.tempo.util.ExternalAudioReader;
 import com.cappielloantonio.tempo.viewmodel.AlbumBottomSheetViewModel;
 import com.cappielloantonio.tempo.viewmodel.HomeViewModel;
 import com.google.android.material.bottomsheet.BottomSheetDialogFragment;
@@ -54,6 +57,10 @@ public class AlbumBottomSheetDialog extends BottomSheetDialogFragment implements
     private AlbumBottomSheetViewModel albumBottomSheetViewModel;
     private AlbumID3 album;
 
+    private TextView removeAllTextView;
+    private List<Child> currentAlbumTracks = Collections.emptyList();
+    private List<MediaItem> currentAlbumMediaItems = Collections.emptyList();
+
     private ListenableFuture<MediaBrowser> mediaBrowserListenableFuture;
 
     @Nullable
@@ -72,6 +79,12 @@ public class AlbumBottomSheetDialog extends BottomSheetDialogFragment implements
         return view;
     }
 
+    @Override
+    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+        MappingUtil.observeExternalAudioRefresh(getViewLifecycleOwner(), this::updateRemoveAllVisibility);
+    }
+
     @Override
     public void onStart() {
         super.onStart();
@@ -163,7 +176,11 @@ public class AlbumBottomSheetDialog extends BottomSheetDialogFragment implements
             List<Download> downloads = songs.stream().map(Download::new).collect(Collectors.toList());
 
             downloadAll.setOnClickListener(v -> {
-                DownloadUtil.getDownloadTracker(requireContext()).download(mediaItems, downloads);
+                if (Preferences.getDownloadDirectoryUri() == null) {
+                    DownloadUtil.getDownloadTracker(requireContext()).download(mediaItems, downloads);
+                } else {
+                    songs.forEach(child -> ExternalAudioWriter.downloadToUserDirectory(requireContext(), child));
+                }
                 dismissBottomSheet();
             });
         });
@@ -182,19 +199,23 @@ public class AlbumBottomSheetDialog extends BottomSheetDialogFragment implements
             });
         });
 
-        TextView removeAll = view.findViewById(R.id.remove_all_text_view);
+        removeAllTextView = view.findViewById(R.id.remove_all_text_view);
         albumBottomSheetViewModel.getAlbumTracks().observe(getViewLifecycleOwner(), songs -> {
-            List<MediaItem> mediaItems = MappingUtil.mapDownloads(songs);
-            List<Download> downloads = songs.stream().map(Download::new).collect(Collectors.toList());
+            currentAlbumTracks = songs != null ? songs : Collections.emptyList();
+            currentAlbumMediaItems = MappingUtil.mapDownloads(currentAlbumTracks);
 
-            removeAll.setOnClickListener(v -> {
-                DownloadUtil.getDownloadTracker(requireContext()).remove(mediaItems, downloads);
+            removeAllTextView.setOnClickListener(v -> {
+                if (Preferences.getDownloadDirectoryUri() == null) {
+                    List<Download> downloads = currentAlbumTracks.stream().map(Download::new).collect(Collectors.toList());
+                    DownloadUtil.getDownloadTracker(requireContext()).remove(currentAlbumMediaItems, downloads);
+                } else {
+                    currentAlbumTracks.forEach(ExternalAudioReader::delete);
+                }
                 dismissBottomSheet();
             });
+            updateRemoveAllVisibility();
         });
 
-        initDownloadUI(removeAll);
-
         TextView goToArtist = view.findViewById(R.id.go_to_artist_text_view);
         goToArtist.setOnClickListener(v -> albumBottomSheetViewModel.getArtist().observe(getViewLifecycleOwner(), artist -> {
             if (artist != null) {
@@ -234,14 +255,29 @@ public class AlbumBottomSheetDialog extends BottomSheetDialogFragment implements
         dismiss();
     }
 
-    private void initDownloadUI(TextView removeAll) {
-        albumBottomSheetViewModel.getAlbumTracks().observe(getViewLifecycleOwner(), songs -> {
-            List<MediaItem> mediaItems = MappingUtil.mapDownloads(songs);
+    private void updateRemoveAllVisibility() {
+        if (removeAllTextView == null) {
+            return;
+        }
 
-            if (DownloadUtil.getDownloadTracker(requireContext()).areDownloaded(mediaItems)) {
-                removeAll.setVisibility(View.VISIBLE);
+        if (currentAlbumTracks == null || currentAlbumTracks.isEmpty()) {
+            removeAllTextView.setVisibility(View.GONE);
+            return;
+        }
+
+        if (Preferences.getDownloadDirectoryUri() == null) {
+            List<MediaItem> mediaItems = currentAlbumMediaItems;
+            if (mediaItems == null || mediaItems.isEmpty()) {
+                removeAllTextView.setVisibility(View.GONE);
+            } else if (DownloadUtil.getDownloadTracker(requireContext()).areDownloaded(mediaItems)) {
+                removeAllTextView.setVisibility(View.VISIBLE);
+            } else {
+                removeAllTextView.setVisibility(View.GONE);
             }
-        });
+        } else {
+            boolean hasLocal = currentAlbumTracks.stream().anyMatch(song -> ExternalAudioReader.getUri(song) != null);
+            removeAllTextView.setVisibility(hasLocal ? View.VISIBLE : View.GONE);
+        }
     }
 
     private void initializeMediaBrowser() {

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/bottomsheetdialog/ArtistBottomSheetDialog.java

@@ -66,7 +66,7 @@ public class ArtistBottomSheetDialog extends BottomSheetDialogFragment implement
         super.onStop();
     }
 
-    // TODO Utilizzare il viewmodel come tramite ed evitare le chiamate dirette
+    // TODO Use the viewmodel as a conduit and avoid direct calls
     private void init(View view) {
         ImageView coverArtist = view.findViewById(R.id.artist_cover_image_view);
         CustomGlideRequest.Builder
@@ -81,7 +81,7 @@ public class ArtistBottomSheetDialog extends BottomSheetDialogFragment implement
         ToggleButton favoriteToggle = view.findViewById(R.id.button_favorite);
         favoriteToggle.setChecked(artistBottomSheetViewModel.getArtist().getStarred() != null);
         favoriteToggle.setOnClickListener(v -> {
-            artistBottomSheetViewModel.setFavorite();
+            artistBottomSheetViewModel.setFavorite(requireContext());
         });
 
         TextView playRadio = view.findViewById(R.id.play_radio_text_view);

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/bottomsheetdialog/DownloadedBottomSheetDialog.java

@@ -25,6 +25,8 @@ import com.cappielloantonio.tempo.util.Constants;
 import com.cappielloantonio.tempo.util.DownloadUtil;
 import com.cappielloantonio.tempo.util.MappingUtil;
 import com.cappielloantonio.tempo.util.MusicUtil;
+import com.cappielloantonio.tempo.util.ExternalAudioReader;
+import com.cappielloantonio.tempo.util.Preferences;
 import com.google.android.material.bottomsheet.BottomSheetDialogFragment;
 import com.google.common.util.concurrent.ListenableFuture;
 
@@ -117,10 +119,13 @@ public class DownloadedBottomSheetDialog extends BottomSheetDialogFragment imple
 
         TextView removeAll = view.findViewById(R.id.remove_all_text_view);
         removeAll.setOnClickListener(v -> {
-            List<MediaItem> mediaItems = MappingUtil.mapDownloads(songs);
-            List<Download> downloads = songs.stream().map(Download::new).collect(Collectors.toList());
-
-            DownloadUtil.getDownloadTracker(requireContext()).remove(mediaItems, downloads);
+            if (Preferences.getDownloadDirectoryUri() == null) {
+                List<MediaItem> mediaItems = MappingUtil.mapDownloads(songs);
+                List<Download> downloads = songs.stream().map(Download::new).collect(Collectors.toList());
+                DownloadUtil.getDownloadTracker(requireContext()).remove(mediaItems, downloads);
+            } else {
+                songs.forEach(ExternalAudioReader::delete);
+            }
 
             dismissBottomSheet();
         });

app/src/main/java/com/cappielloantonio/tempo/ui/fragment/bottomsheetdialog/SongBottomSheetDialog.java

@@ -13,6 +13,7 @@ import android.widget.TextView;
 import android.widget.Toast;
 import android.widget.ToggleButton;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.lifecycle.ViewModelProvider;
 import androidx.media3.common.util.UnstableApi;
@@ -31,6 +32,7 @@ import com.cappielloantonio.tempo.ui.dialog.PlaylistChooserDialog;
 import com.cappielloantonio.tempo.ui.dialog.RatingDialog;
 import com.cappielloantonio.tempo.util.Constants;
 import com.cappielloantonio.tempo.util.DownloadUtil;
+import com.cappielloantonio.tempo.util.ExternalAudioReader;
 import com.cappielloantonio.tempo.util.MappingUtil;
 import com.cappielloantonio.tempo.util.MusicUtil;
 import com.cappielloantonio.tempo.util.Preferences;
@@ -39,6 +41,10 @@ import com.cappielloantonio.tempo.viewmodel.SongBottomSheetViewModel;
 import com.google.android.material.bottomsheet.BottomSheetDialogFragment;
 import com.google.common.util.concurrent.ListenableFuture;
 
+import android.content.Intent;
+import androidx.media3.common.MediaItem;
+import com.cappielloantonio.tempo.util.ExternalAudioWriter;
+
 import java.util.ArrayList;
 import java.util.Collections;
 
@@ -48,6 +54,9 @@ public class SongBottomSheetDialog extends BottomSheetDialogFragment implements
     private SongBottomSheetViewModel songBottomSheetViewModel;
     private Child song;
 
+    private TextView downloadButton;
+    private TextView removeButton;
+
     private ListenableFuture<MediaBrowser> mediaBrowserListenableFuture;
 
     @Nullable
@@ -66,6 +75,12 @@ public class SongBottomSheetDialog extends BottomSheetDialogFragment implements
         return view;
     }
 
+    @Override
+    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+        MappingUtil.observeExternalAudioRefresh(getViewLifecycleOwner(), this::updateDownloadButtons);
+    }
+
     @Override
     public void onStart() {
         super.onStart();
@@ -157,25 +172,33 @@ public class SongBottomSheetDialog extends BottomSheetDialogFragment implements
             dismissBottomSheet();
         });
 
-        TextView download = view.findViewById(R.id.download_text_view);
-        download.setOnClickListener(v -> {
-            DownloadUtil.getDownloadTracker(requireContext()).download(
-                    MappingUtil.mapDownload(song),
-                    new Download(song)
-            );
+        downloadButton = view.findViewById(R.id.download_text_view);
+        downloadButton.setOnClickListener(v -> {
+            if (Preferences.getDownloadDirectoryUri() == null) {
+                DownloadUtil.getDownloadTracker(requireContext()).download(
+                        MappingUtil.mapDownload(song),
+                        new Download(song)
+                );
+            } else {
+                ExternalAudioWriter.downloadToUserDirectory(requireContext(), song);
+            }
             dismissBottomSheet();
         });
 
-        TextView remove = view.findViewById(R.id.remove_text_view);
-        remove.setOnClickListener(v -> {
-            DownloadUtil.getDownloadTracker(requireContext()).remove(
-                    MappingUtil.mapDownload(song),
-                    new Download(song)
-            );
+        removeButton = view.findViewById(R.id.remove_text_view);
+        removeButton.setOnClickListener(v -> {
+            if (Preferences.getDownloadDirectoryUri() == null) {
+                DownloadUtil.getDownloadTracker(requireContext()).remove(
+                        MappingUtil.mapDownload(song),
+                        new Download(song)
+                );
+            } else {
+                ExternalAudioReader.delete(song);
+            }
             dismissBottomSheet();
         });
 
-        initDownloadUI(download, remove);
+        updateDownloadButtons();
 
         TextView addToPlaylist = view.findViewById(R.id.add_to_playlist_text_view);
         addToPlaylist.setOnClickListener(v -> {
@@ -243,12 +266,19 @@ public class SongBottomSheetDialog extends BottomSheetDialogFragment implements
         dismiss();
     }
 
-    private void initDownloadUI(TextView download, TextView remove) {
-        if (DownloadUtil.getDownloadTracker(requireContext()).isDownloaded(song.getId())) {
-            remove.setVisibility(View.VISIBLE);
+    private void updateDownloadButtons() {
+        if (downloadButton == null || removeButton == null) {
+            return;
+        }
+
+        if (Preferences.getDownloadDirectoryUri() == null) {
+            boolean downloaded = DownloadUtil.getDownloadTracker(requireContext()).isDownloaded(song.getId());
+            downloadButton.setVisibility(downloaded ? View.GONE : View.VISIBLE);
+            removeButton.setVisibility(downloaded ? View.VISIBLE : View.GONE);
         } else {
-            download.setVisibility(View.VISIBLE);
-            remove.setVisibility(View.GONE);
+            boolean hasLocal = ExternalAudioReader.getUri(song) != null;
+            downloadButton.setVisibility(hasLocal ? View.GONE : View.VISIBLE);
+            removeButton.setVisibility(hasLocal ? View.VISIBLE : View.GONE);
         }
     }
 

app/src/main/java/com/cappielloantonio/tempo/util/Constants.kt

@@ -85,6 +85,13 @@ object Constants {
     const val MEDIA_LEAST_RECENTLY_STARRED = "MEDIA_LEAST_RECENTLY_STARRED"
 
     const val DOWNLOAD_URI = "rest/download"
+    const val ACTION_PLAY_EXTERNAL_DOWNLOAD = "com.cappielloantonio.tempo.action.PLAY_EXTERNAL_DOWNLOAD"
+    const val EXTRA_DOWNLOAD_URI = "EXTRA_DOWNLOAD_URI"
+    const val EXTRA_DOWNLOAD_MEDIA_ID = "EXTRA_DOWNLOAD_MEDIA_ID"
+    const val EXTRA_DOWNLOAD_TITLE = "EXTRA_DOWNLOAD_TITLE"
+    const val EXTRA_DOWNLOAD_ARTIST = "EXTRA_DOWNLOAD_ARTIST"
+    const val EXTRA_DOWNLOAD_ALBUM = "EXTRA_DOWNLOAD_ALBUM"
+    const val EXTRA_DOWNLOAD_DURATION = "EXTRA_DOWNLOAD_DURATION"
 
     const val DOWNLOAD_TYPE_TRACK = "download_type_track"
     const val DOWNLOAD_TYPE_ALBUM = "download_type_album"
@@ -116,4 +123,13 @@ object Constants {
     const val HOME_SECTOR_RECENTLY_ADDED = "HOME_SECTOR_RECENTLY_ADDED"
     const val HOME_SECTOR_PINNED_PLAYLISTS = "HOME_SECTOR_PINNED_PLAYLISTS"
     const val HOME_SECTOR_SHARED = "HOME_SECTOR_SHARED"
+
+    const val CUSTOM_COMMAND_TOGGLE_SHUFFLE_MODE_ON = "android.media3.session.demo.SHUFFLE_ON"
+    const val CUSTOM_COMMAND_TOGGLE_SHUFFLE_MODE_OFF = "android.media3.session.demo.SHUFFLE_OFF"
+    const val CUSTOM_COMMAND_TOGGLE_HEART_ON = "android.media3.session.demo.HEART_ON"
+    const val CUSTOM_COMMAND_TOGGLE_HEART_OFF = "android.media3.session.demo.HEART_OFF"
+    const val CUSTOM_COMMAND_TOGGLE_HEART_LOADING = "android.media3.session.demo.HEART_LOADING"
+    const val CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_OFF = "android.media3.session.demo.REPEAT_OFF"
+    const val CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_ONE = "android.media3.session.demo.REPEAT_ONE"
+    const val CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_ALL = "android.media3.session.demo.REPEAT_ALL"
 }

app/src/main/java/com/cappielloantonio/tempo/util/DownloadUtil.java

@@ -78,32 +78,26 @@ public final class DownloadUtil {
         return httpDataSourceFactory;
     }
 
-    public static synchronized DataSource.Factory getDataSourceFactory(Context context) {
-        if (dataSourceFactory == null) {
-            context = context.getApplicationContext();
+    public static synchronized DataSource.Factory getUpstreamDataSourceFactory(Context context) {
+        DefaultDataSource.Factory upstreamFactory = new DefaultDataSource.Factory(context, getHttpDataSourceFactory());
+        dataSourceFactory = buildReadOnlyCacheDataSource(upstreamFactory, getDownloadCache(context));
+        return dataSourceFactory;
+    }
 
-            DefaultDataSource.Factory upstreamFactory = new DefaultDataSource.Factory(context, getHttpDataSourceFactory());
-
-            if (Preferences.getStreamingCacheSize() > 0) {
-                CacheDataSource.Factory streamCacheFactory = new CacheDataSource.Factory()
-                        .setCache(getStreamingCache(context))
-                        .setUpstreamDataSourceFactory(upstreamFactory);
-
-                ResolvingDataSource.Factory resolvingFactory = new ResolvingDataSource.Factory(
-                        new StreamingCacheDataSource.Factory(streamCacheFactory),
-                        dataSpec -> {
-                            DataSpec.Builder builder = dataSpec.buildUpon();
-                            builder.setFlags(dataSpec.flags & ~DataSpec.FLAG_DONT_CACHE_IF_LENGTH_UNKNOWN);
-                            return builder.build();
-                        }
-                );
-
-                dataSourceFactory = buildReadOnlyCacheDataSource(resolvingFactory, getDownloadCache(context));
-            } else {
-                dataSourceFactory = buildReadOnlyCacheDataSource(upstreamFactory, getDownloadCache(context));
-            }
-        }
+    public static synchronized DataSource.Factory getCacheDataSourceFactory(Context context) {
+        CacheDataSource.Factory streamCacheFactory = new CacheDataSource.Factory()
+                .setCache(getStreamingCache(context))
+                .setUpstreamDataSourceFactory(getUpstreamDataSourceFactory(context));
 
+        ResolvingDataSource.Factory resolvingFactory = new ResolvingDataSource.Factory(
+                new StreamingCacheDataSource.Factory(streamCacheFactory),
+                dataSpec -> {
+                    DataSpec.Builder builder = dataSpec.buildUpon();
+                    builder.setFlags(dataSpec.flags & ~DataSpec.FLAG_DONT_CACHE_IF_LENGTH_UNKNOWN);
+                    return builder.build();
+                }
+        );
+        dataSourceFactory = buildReadOnlyCacheDataSource(resolvingFactory, getDownloadCache(context));
         return dataSourceFactory;
     }
 
@@ -193,19 +187,21 @@ public final class DownloadUtil {
 
     private static synchronized File getDownloadDirectory(Context context) {
         if (downloadDirectory == null) {
-            if (Preferences.getDownloadStoragePreference() == 0) {
+            int pref = Preferences.getDownloadStoragePreference();
+            if (pref == 0) {
                 downloadDirectory = context.getExternalFilesDirs(null)[0];
                 if (downloadDirectory == null) {
                     downloadDirectory = context.getFilesDir();
                 }
-            } else {
+            } else if (pref == 1) {
                 try {
                     downloadDirectory = context.getExternalFilesDirs(null)[1];
                 } catch (Exception exception) {
                     downloadDirectory = context.getExternalFilesDirs(null)[0];
                     Preferences.setDownloadStoragePreference(0);
                 }
-
+            } else {
+                downloadDirectory = context.getExternalFilesDirs(null)[0];
             }
         }
 

app/src/main/java/com/cappielloantonio/tempo/util/DynamicMediaSourceFactory.kt

@@ -0,0 +1,69 @@
+package com.cappielloantonio.tempo.util
+
+import android.content.Context
+import androidx.media3.common.C
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MimeTypes
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.DataSource
+import androidx.media3.exoplayer.drm.DrmSessionManagerProvider
+import androidx.media3.exoplayer.hls.HlsMediaSource
+import androidx.media3.exoplayer.source.MediaSource
+import androidx.media3.exoplayer.source.ProgressiveMediaSource
+import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
+import androidx.media3.extractor.DefaultExtractorsFactory
+import androidx.media3.extractor.ExtractorsFactory
+
+@UnstableApi
+class DynamicMediaSourceFactory(
+    private val context: Context
+) : MediaSource.Factory {
+
+    override fun createMediaSource(mediaItem: MediaItem): MediaSource {
+        val mediaType: String? = mediaItem.mediaMetadata.extras?.getString("type", "")
+
+        val streamingCacheSize = Preferences.getStreamingCacheSize()
+        val bypassCache = mediaType == Constants.MEDIA_TYPE_RADIO
+
+        val useUpstream = when {
+            streamingCacheSize.toInt() == 0 -> true
+            streamingCacheSize > 0 && bypassCache -> true
+            streamingCacheSize > 0 && !bypassCache -> false
+            else -> true
+        }
+
+        val dataSourceFactory: DataSource.Factory = if (useUpstream) {
+            DownloadUtil.getUpstreamDataSourceFactory(context)
+        } else {
+            DownloadUtil.getCacheDataSourceFactory(context)
+        }
+
+        return when {
+            mediaItem.localConfiguration?.mimeType == MimeTypes.APPLICATION_M3U8 ||
+                    mediaItem.localConfiguration?.uri?.lastPathSegment?.endsWith(".m3u8", ignoreCase = true) == true -> {
+                HlsMediaSource.Factory(dataSourceFactory).createMediaSource(mediaItem)
+            }
+
+            else -> {
+                val extractorsFactory: ExtractorsFactory = DefaultExtractorsFactory()
+                ProgressiveMediaSource.Factory(dataSourceFactory, extractorsFactory)
+                    .createMediaSource(mediaItem)
+            }
+        }
+    }
+
+    override fun setDrmSessionManagerProvider(drmSessionManagerProvider: DrmSessionManagerProvider): MediaSource.Factory {
+        TODO("Not yet implemented")
+    }
+
+    override fun setLoadErrorHandlingPolicy(loadErrorHandlingPolicy: LoadErrorHandlingPolicy): MediaSource.Factory {
+        TODO("Not yet implemented")
+    }
+
+    override fun getSupportedTypes(): IntArray {
+        return intArrayOf(
+            C.CONTENT_TYPE_HLS,
+            C.CONTENT_TYPE_OTHER
+        )
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/util/ExternalAudioReader.java

@@ -0,0 +1,244 @@
+package com.cappielloantonio.tempo.util;
+
+import android.net.Uri;
+import android.os.Looper;
+import android.os.SystemClock;
+
+import androidx.documentfile.provider.DocumentFile;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.subsonic.models.Child;
+import com.cappielloantonio.tempo.subsonic.models.PodcastEpisode;
+
+import java.text.Normalizer;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class ExternalAudioReader {
+
+    private static final Map<String, DocumentFile> cache = new ConcurrentHashMap<>();
+    private static final Object LOCK = new Object();
+    private static final ExecutorService REFRESH_EXECUTOR = Executors.newSingleThreadExecutor();
+    private static final MutableLiveData<Long> refreshEvents = new MutableLiveData<>();
+
+    private static volatile String cachedDirUri;
+    private static volatile boolean refreshInProgress = false;
+    private static volatile boolean refreshQueued = false;
+
+    private static String sanitizeFileName(String name) {
+        String sanitized = name.replaceAll("[\\/:*?\\\"<>|]", "_");
+        sanitized = sanitized.replaceAll("\\s+", " ").trim();
+        return sanitized;
+    }
+
+    private static String normalizeForComparison(String name) {
+        String s = sanitizeFileName(name);
+        s = Normalizer.normalize(s, Normalizer.Form.NFKD);
+        s = s.replaceAll("\\p{InCombiningDiacriticalMarks}+", "");
+        return s.toLowerCase(Locale.ROOT);
+    }
+
+    private static void ensureCache() {
+        String uriString = Preferences.getDownloadDirectoryUri();
+        if (uriString == null) {
+            synchronized (LOCK) {
+                cache.clear();
+                cachedDirUri = null;
+            }
+            ExternalDownloadMetadataStore.clear();
+            return;
+        }
+
+        if (uriString.equals(cachedDirUri)) {
+            return;
+        }
+
+        boolean runSynchronously = false;
+        synchronized (LOCK) {
+            if (refreshInProgress) {
+                return;
+            }
+
+            if (Looper.myLooper() == Looper.getMainLooper()) {
+                scheduleRefreshLocked();
+                return;
+            }
+
+            refreshInProgress = true;
+            runSynchronously = true;
+        }
+
+        if (runSynchronously) {
+            try {
+                rebuildCache();
+            } finally {
+                onRefreshFinished();
+            }
+        }
+    }
+
+    public static void refreshCache() {
+        refreshCacheAsync();
+    }
+
+    public static void refreshCacheAsync() {
+        synchronized (LOCK) {
+            cachedDirUri = null;
+            cache.clear();
+        }
+        requestRefresh();
+    }
+
+    public static LiveData<Long> getRefreshEvents() {
+        return refreshEvents;
+    }
+
+    private static String buildKey(String artist, String title, String album) {
+        String name = artist != null && !artist.isEmpty() ? artist + " - " + title : title;
+        if (album != null && !album.isEmpty()) name += " (" + album + ")";
+        return normalizeForComparison(name);
+    }
+
+    private static Uri findUri(String artist, String title, String album) {
+        ensureCache();
+        if (cachedDirUri == null) return null;
+
+        DocumentFile file = cache.get(buildKey(artist, title, album));
+        return file != null && file.exists() ? file.getUri() : null;
+    }
+
+    public static Uri getUri(Child media) {
+        return findUri(media.getArtist(), media.getTitle(), media.getAlbum());
+    }
+
+    public static Uri getUri(PodcastEpisode episode) {
+        return findUri(episode.getArtist(), episode.getTitle(), episode.getAlbum());
+    }
+
+    public static synchronized void removeMetadata(Child media) {
+        if (media == null) {
+            return;
+        }
+
+        String key = buildKey(media.getArtist(), media.getTitle(), media.getAlbum());
+        cache.remove(key);
+        ExternalDownloadMetadataStore.remove(key);
+    }
+
+    public static boolean delete(Child media) {
+        ensureCache();
+        if (cachedDirUri == null) return false;
+
+        String key = buildKey(media.getArtist(), media.getTitle(), media.getAlbum());
+        DocumentFile file = cache.get(key);
+        boolean deleted = false;
+        if (file != null && file.exists()) {
+            deleted = file.delete();
+        }
+        if (deleted) {
+            cache.remove(key);
+            ExternalDownloadMetadataStore.remove(key);
+        }
+        return deleted;
+    }
+
+    private static void requestRefresh() {
+        synchronized (LOCK) {
+            scheduleRefreshLocked();
+        }
+    }
+
+    private static void scheduleRefreshLocked() {
+        if (refreshInProgress) {
+            refreshQueued = true;
+            return;
+        }
+
+        refreshInProgress = true;
+        REFRESH_EXECUTOR.execute(() -> {
+            try {
+                rebuildCache();
+            } finally {
+                onRefreshFinished();
+            }
+        });
+    }
+
+    private static void rebuildCache() {
+        String uriString = Preferences.getDownloadDirectoryUri();
+        if (uriString == null) {
+            synchronized (LOCK) {
+                cache.clear();
+                cachedDirUri = null;
+            }
+            ExternalDownloadMetadataStore.clear();
+            return;
+        }
+
+        DocumentFile directory = DocumentFile.fromTreeUri(App.getContext(), Uri.parse(uriString));
+        Map<String, Long> expectedSizes = ExternalDownloadMetadataStore.snapshot();
+        Set<String> verifiedKeys = new HashSet<>();
+        Map<String, DocumentFile> newEntries = new HashMap<>();
+
+        if (directory != null && directory.canRead()) {
+            for (DocumentFile file : directory.listFiles()) {
+                if (file == null || file.isDirectory()) continue;
+                String existing = file.getName();
+                if (existing == null) continue;
+
+                String base = existing.replaceFirst("\\.[^\\.]+$", "");
+                String key = normalizeForComparison(base);
+                Long expected = expectedSizes.get(key);
+                long actualLength = file.length();
+
+                if (expected != null && expected > 0 && actualLength == expected) {
+                    newEntries.put(key, file);
+                    verifiedKeys.add(key);
+                } else {
+                    ExternalDownloadMetadataStore.remove(key);
+                }
+            }
+        }
+
+        if (!expectedSizes.isEmpty()) {
+            if (verifiedKeys.isEmpty()) {
+                ExternalDownloadMetadataStore.clear();
+            } else {
+                for (String key : expectedSizes.keySet()) {
+                    if (!verifiedKeys.contains(key)) {
+                        ExternalDownloadMetadataStore.remove(key);
+                    }
+                }
+            }
+        }
+
+        synchronized (LOCK) {
+            cache.clear();
+            cache.putAll(newEntries);
+            cachedDirUri = uriString;
+        }
+    }
+
+    private static void onRefreshFinished() {
+        boolean runAgain;
+        synchronized (LOCK) {
+            refreshInProgress = false;
+            runAgain = refreshQueued;
+            refreshQueued = false;
+        }
+
+        refreshEvents.postValue(SystemClock.elapsedRealtime());
+
+        if (runAgain) {
+            requestRefresh();
+        }
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/util/ExternalAudioWriter.java

@@ -0,0 +1,322 @@
+package com.cappielloantonio.tempo.util;
+
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.provider.Settings;
+import android.webkit.MimeTypeMap;
+
+import androidx.core.app.NotificationCompat;
+import androidx.documentfile.provider.DocumentFile;
+import androidx.media3.common.MediaItem;
+
+import com.cappielloantonio.tempo.model.Download;
+import com.cappielloantonio.tempo.repository.DownloadRepository;
+import com.cappielloantonio.tempo.subsonic.models.Child;
+import com.cappielloantonio.tempo.ui.activity.MainActivity;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.text.Normalizer;
+import java.util.Locale;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class ExternalAudioWriter {
+
+    private static final ExecutorService EXECUTOR = Executors.newSingleThreadExecutor();
+    private static final int BUFFER_SIZE = 8192;
+    private static final int CONNECT_TIMEOUT_MS = 15_000;
+    private static final int READ_TIMEOUT_MS = 60_000;
+
+    private ExternalAudioWriter() {
+    }
+
+    private static String sanitizeFileName(String name) {
+        String sanitized = name.replaceAll("[\\/:*?\\\"<>|]", "_");
+        sanitized = sanitized.replaceAll("\\s+", " ").trim();
+        return sanitized;
+    }
+
+    private static String normalizeForComparison(String name) {
+        String s = sanitizeFileName(name);
+        s = Normalizer.normalize(s, Normalizer.Form.NFKD);
+        s = s.replaceAll("\\p{InCombiningDiacriticalMarks}+", "");
+        return s.toLowerCase(Locale.ROOT);
+    }
+
+    private static DocumentFile findFile(DocumentFile dir, String fileName) {
+        String normalized = normalizeForComparison(fileName);
+        for (DocumentFile file : dir.listFiles()) {
+            if (file.isDirectory()) continue;
+            String existing = file.getName();
+            if (existing != null && normalizeForComparison(existing).equals(normalized)) {
+                return file;
+            }
+        }
+        return null;
+    }
+
+    public static void downloadToUserDirectory(Context context, Child child) {
+        if (context == null || child == null) {
+            return;
+        }
+        Context appContext = context.getApplicationContext();
+        MediaItem mediaItem = MappingUtil.mapDownload(child);
+        String fallbackName = child.getTitle() != null ? child.getTitle() : child.getId();
+        EXECUTOR.execute(() -> performDownload(appContext, mediaItem, fallbackName, child));
+    }
+
+    private static void performDownload(Context context, MediaItem mediaItem, String fallbackName, Child child) {
+        String uriString = Preferences.getDownloadDirectoryUri();
+        if (uriString == null) {
+            notifyUnavailable(context);
+            return;
+        }
+
+        DocumentFile directory = DocumentFile.fromTreeUri(context, Uri.parse(uriString));
+        if (directory == null || !directory.canWrite()) {
+            notifyFailure(context, "Cannot write to folder.");
+            return;
+        }
+
+        String artist = child.getArtist() != null ? child.getArtist() : "";
+        String title = child.getTitle() != null ? child.getTitle() : fallbackName;
+        String album = child.getAlbum() != null ? child.getAlbum() : "";
+        String baseName = artist.isEmpty() ? title : artist + " - " + title;
+        if (!album.isEmpty()) baseName += " (" + album + ")";
+        if (baseName.isEmpty()) {
+            baseName = fallbackName != null ? fallbackName : "download";
+        }
+        String metadataKey = normalizeForComparison(baseName);
+
+        Uri mediaUri = mediaItem != null && mediaItem.requestMetadata != null
+                ? mediaItem.requestMetadata.mediaUri
+                : null;
+        if (mediaUri == null) {
+            notifyFailure(context, "Invalid media URI.");
+            ExternalDownloadMetadataStore.remove(metadataKey);
+            return;
+        }
+        String scheme = mediaUri.getScheme();
+        if (scheme == null || (!scheme.equalsIgnoreCase("http") && !scheme.equalsIgnoreCase("https"))) {
+            notifyFailure(context, "Unsupported media URI.");
+            ExternalDownloadMetadataStore.remove(metadataKey);
+            return;
+        }
+
+        HttpURLConnection connection = null;
+        DocumentFile targetFile = null;
+        try {
+            connection = (HttpURLConnection) new URL(mediaUri.toString()).openConnection();
+            connection.setConnectTimeout(CONNECT_TIMEOUT_MS);
+            connection.setReadTimeout(READ_TIMEOUT_MS);
+            connection.setRequestProperty("Accept-Encoding", "identity");
+            connection.connect();
+
+            int responseCode = connection.getResponseCode();
+            if (responseCode >= HttpURLConnection.HTTP_BAD_REQUEST) {
+                notifyFailure(context, "Server returned " + responseCode);
+                ExternalDownloadMetadataStore.remove(metadataKey);
+                return;
+            }
+
+            String mimeType = connection.getContentType();
+            if (mimeType == null || mimeType.isEmpty()) {
+                mimeType = "application/octet-stream";
+            }
+
+            String extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType);
+            if (extension == null || extension.isEmpty()) {
+                String suffix = child.getSuffix();
+                if (suffix != null && !suffix.isEmpty()) {
+                    extension = suffix;
+                } else {
+                    extension = "bin";
+                }
+            }
+
+            String sanitized = sanitizeFileName(baseName);
+            if (sanitized.isEmpty()) sanitized = sanitizeFileName(fallbackName);
+            if (sanitized.isEmpty()) sanitized = "download";
+            String fileName = sanitized + "." + extension;
+
+            DocumentFile existingFile = findFile(directory, fileName);
+            long remoteLength = connection.getContentLengthLong();
+            Long recordedSize = ExternalDownloadMetadataStore.getSize(metadataKey);
+            if (existingFile != null && existingFile.exists()) {
+                long localLength = existingFile.length();
+                boolean matches = false;
+                if (remoteLength > 0 && localLength == remoteLength) {
+                    matches = true;
+                } else if (remoteLength <= 0 && recordedSize != null && localLength == recordedSize) {
+                    matches = true;
+                }
+                if (matches) {
+                    ExternalDownloadMetadataStore.recordSize(metadataKey, localLength);
+                    recordDownload(child, existingFile.getUri());
+                    ExternalAudioReader.refreshCacheAsync();
+                    notifyExists(context, fileName);
+                    return;
+                } else {
+                    existingFile.delete();
+                    ExternalDownloadMetadataStore.remove(metadataKey);
+                }
+            }
+
+            targetFile = directory.createFile(mimeType, fileName);
+            if (targetFile == null) {
+                notifyFailure(context, "Failed to create file.");
+                return;
+            }
+
+            Uri targetUri = targetFile.getUri();
+            try (InputStream in = connection.getInputStream();
+                 OutputStream out = context.getContentResolver().openOutputStream(targetUri)) {
+                if (out == null) {
+                    notifyFailure(context, "Cannot open output stream.");
+                    targetFile.delete();
+                    return;
+                }
+
+                byte[] buffer = new byte[BUFFER_SIZE];
+                int len;
+                long total = 0;
+                while ((len = in.read(buffer)) != -1) {
+                    out.write(buffer, 0, len);
+                    total += len;
+                }
+                out.flush();
+
+                if (total <= 0) {
+                    targetFile.delete();
+                    ExternalDownloadMetadataStore.remove(metadataKey);
+                    notifyFailure(context, "Empty download.");
+                    return;
+                }
+
+                if (remoteLength > 0 && total != remoteLength) {
+                    targetFile.delete();
+                    ExternalDownloadMetadataStore.remove(metadataKey);
+                    notifyFailure(context, "Incomplete download.");
+                    return;
+                }
+
+                ExternalDownloadMetadataStore.recordSize(metadataKey, total);
+                recordDownload(child, targetUri);
+                notifySuccess(context, fileName, child, targetUri);
+                ExternalAudioReader.refreshCacheAsync();
+            }
+        } catch (Exception e) {
+            if (targetFile != null) {
+                targetFile.delete();
+            }
+            ExternalDownloadMetadataStore.remove(metadataKey);
+            notifyFailure(context, e.getMessage() != null ? e.getMessage() : "Download failed");
+        } finally {
+            if (connection != null) {
+                connection.disconnect();
+            }
+        }
+    }
+
+    private static void notifyUnavailable(Context context) {
+        NotificationManager manager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+        Intent settingsIntent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
+                Uri.fromParts("package", context.getPackageName(), null));
+        PendingIntent openSettings = PendingIntent.getActivity(context, 0, settingsIntent,
+                PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);
+
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, DownloadUtil.DOWNLOAD_NOTIFICATION_CHANNEL_ID)
+                .setContentTitle("No download folder set")
+                .setContentText("Tap to set one in settings")
+                .setSmallIcon(android.R.drawable.stat_notify_error)
+                .setPriority(NotificationCompat.PRIORITY_LOW)
+                .setSilent(true)
+                .setContentIntent(openSettings)
+                .setAutoCancel(true);
+
+        manager.notify(1011, builder.build());
+    }
+
+    private static void notifyFailure(Context context, String message) {
+        NotificationManager manager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, DownloadUtil.DOWNLOAD_NOTIFICATION_CHANNEL_ID)
+                .setContentTitle("Download failed")
+                .setContentText(message)
+                .setSmallIcon(android.R.drawable.stat_notify_error)
+                .setAutoCancel(true);
+        manager.notify((int) System.currentTimeMillis(), builder.build());
+    }
+
+    private static void notifySuccess(Context context, String name, Child child, Uri fileUri) {
+        NotificationManager manager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, DownloadUtil.DOWNLOAD_NOTIFICATION_CHANNEL_ID)
+                .setContentTitle("Download complete")
+                .setContentText(name)
+                .setSmallIcon(android.R.drawable.stat_sys_download_done)
+                .setAutoCancel(true);
+
+        PendingIntent playIntent = buildPlayIntent(context, child, fileUri);
+        if (playIntent != null) {
+            builder.setContentIntent(playIntent);
+        }
+
+        manager.notify((int) System.currentTimeMillis(), builder.build());
+    }
+
+    private static void recordDownload(Child child, Uri fileUri) {
+        if (child == null) {
+            return;
+        }
+
+        Download download = new Download(child);
+        download.setDownloadState(1);
+        if (fileUri != null) {
+            download.setDownloadUri(fileUri.toString());
+        }
+
+        new DownloadRepository().insert(download);
+    }
+
+    private static void notifyExists(Context context, String name) {
+        NotificationManager manager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context, DownloadUtil.DOWNLOAD_NOTIFICATION_CHANNEL_ID)
+                .setContentTitle("Already downloaded")
+                .setContentText(name)
+                .setSmallIcon(android.R.drawable.stat_sys_warning)
+                .setAutoCancel(true);
+        manager.notify((int) System.currentTimeMillis(), builder.build());
+    }
+
+    private static PendingIntent buildPlayIntent(Context context, Child child, Uri fileUri) {
+        if (fileUri == null) return null;
+        Intent intent = new Intent(context, MainActivity.class)
+                .setAction(Constants.ACTION_PLAY_EXTERNAL_DOWNLOAD)
+                .putExtra(Constants.EXTRA_DOWNLOAD_URI, fileUri.toString())
+                .putExtra(Constants.EXTRA_DOWNLOAD_MEDIA_ID, child.getId())
+                .putExtra(Constants.EXTRA_DOWNLOAD_TITLE, child.getTitle())
+                .putExtra(Constants.EXTRA_DOWNLOAD_ARTIST, child.getArtist())
+                .putExtra(Constants.EXTRA_DOWNLOAD_ALBUM, child.getAlbum())
+                .putExtra(Constants.EXTRA_DOWNLOAD_DURATION, child.getDuration() != null ? child.getDuration() : 0)
+                .addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+
+        int requestCode;
+        if (child.getId() != null) {
+            requestCode = Math.abs(child.getId().hashCode());
+        } else {
+            requestCode = Math.abs(fileUri.toString().hashCode());
+        }
+
+        return PendingIntent.getActivity(
+                context,
+                requestCode,
+                intent,
+                PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
+        );
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/util/ExternalDownloadMetadataStore.java

@@ -0,0 +1,123 @@
+package com.cappielloantonio.tempo.util;
+
+import android.content.SharedPreferences;
+
+import androidx.annotation.Nullable;
+
+import com.cappielloantonio.tempo.App;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+public final class ExternalDownloadMetadataStore {
+
+    private static final String PREF_KEY = "external_download_metadata";
+
+    private ExternalDownloadMetadataStore() {
+    }
+
+    private static SharedPreferences preferences() {
+        return App.getInstance().getPreferences();
+    }
+
+    private static JSONObject readAll() {
+        String raw = preferences().getString(PREF_KEY, "{}");
+        try {
+            return new JSONObject(raw);
+        } catch (JSONException e) {
+            return new JSONObject();
+        }
+    }
+
+    private static void writeAll(JSONObject object) {
+        preferences().edit().putString(PREF_KEY, object.toString()).apply();
+    }
+
+    public static synchronized void clear() {
+        writeAll(new JSONObject());
+    }
+
+    public static synchronized void recordSize(String key, long size) {
+        if (key == null || size <= 0) {
+            return;
+        }
+        JSONObject object = readAll();
+        try {
+            object.put(key, size);
+        } catch (JSONException ignored) {
+        }
+        writeAll(object);
+    }
+
+    public static synchronized void remove(String key) {
+        if (key == null) {
+            return;
+        }
+        JSONObject object = readAll();
+        object.remove(key);
+        writeAll(object);
+    }
+
+    @Nullable
+    public static synchronized Long getSize(String key) {
+        if (key == null) {
+            return null;
+        }
+        JSONObject object = readAll();
+        if (!object.has(key)) {
+            return null;
+        }
+        long size = object.optLong(key, -1L);
+        return size > 0 ? size : null;
+    }
+
+    public static synchronized Map<String, Long> snapshot() {
+        JSONObject object = readAll();
+        if (object.length() == 0) {
+            return Collections.emptyMap();
+        }
+        Map<String, Long> sizes = new HashMap<>();
+        Iterator<String> keys = object.keys();
+        while (keys.hasNext()) {
+            String key = keys.next();
+            long size = object.optLong(key, -1L);
+            if (size > 0) {
+                sizes.put(key, size);
+            }
+        }
+        return sizes;
+    }
+
+    public static synchronized void retainOnly(Set<String> keysToKeep) {
+        if (keysToKeep == null || keysToKeep.isEmpty()) {
+            clear();
+            return;
+        }
+        JSONObject object = readAll();
+        if (object.length() == 0) {
+            return;
+        }
+        Set<String> keys = new HashSet<>();
+        Iterator<String> iterator = object.keys();
+        while (iterator.hasNext()) {
+            keys.add(iterator.next());
+        }
+        boolean changed = false;
+        for (String key : keys) {
+            if (!keysToKeep.contains(key)) {
+                object.remove(key);
+                changed = true;
+            }
+        }
+        if (changed) {
+            writeAll(object);
+        }
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/util/MappingUtil.java

@@ -4,10 +4,12 @@ import android.net.Uri;
 import android.os.Bundle;
 
 import androidx.annotation.OptIn;
+import androidx.lifecycle.LifecycleOwner;
 import androidx.media3.common.MediaItem;
 import androidx.media3.common.MediaMetadata;
 import androidx.media3.common.MimeTypes;
 import androidx.media3.common.util.UnstableApi;
+import androidx.media3.common.HeartRating;
 
 import com.cappielloantonio.tempo.App;
 import com.cappielloantonio.tempo.glide.CustomGlideRequest;
@@ -16,6 +18,7 @@ import com.cappielloantonio.tempo.repository.DownloadRepository;
 import com.cappielloantonio.tempo.subsonic.models.Child;
 import com.cappielloantonio.tempo.subsonic.models.InternetRadioStation;
 import com.cappielloantonio.tempo.subsonic.models.PodcastEpisode;
+import com.google.common.collect.ImmutableList;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -83,6 +86,13 @@ public class MappingUtil {
                                 .setAlbumTitle(media.getAlbum())
                                 .setArtist(media.getArtist())
                                 .setArtworkUri(artworkUri)
+                                .setUserRating(new HeartRating(media.getStarred() != null))
+                                .setSupportedCommands(
+                                        ImmutableList.of(
+                                                Constants.CUSTOM_COMMAND_TOGGLE_HEART_ON,
+                                                Constants.CUSTOM_COMMAND_TOGGLE_HEART_OFF
+                                        )
+                                )
                                 .setExtras(bundle)
                                 .setIsBrowsable(false)
                                 .setIsPlayable(true)
@@ -217,12 +227,20 @@ public class MappingUtil {
     }
 
     private static Uri getUri(Child media) {
+        if (Preferences.getDownloadDirectoryUri() != null) {
+            Uri local = ExternalAudioReader.getUri(media);
+            return local != null ? local : MusicUtil.getStreamUri(media.getId());
+        }
         return DownloadUtil.getDownloadTracker(App.getContext()).isDownloaded(media.getId())
                 ? getDownloadUri(media.getId())
                 : MusicUtil.getStreamUri(media.getId());
     }
 
     private static Uri getUri(PodcastEpisode podcastEpisode) {
+        if (Preferences.getDownloadDirectoryUri() != null) {
+            Uri local = ExternalAudioReader.getUri(podcastEpisode);
+            return local != null ? local : MusicUtil.getStreamUri(podcastEpisode.getStreamId());
+        }
         return DownloadUtil.getDownloadTracker(App.getContext()).isDownloaded(podcastEpisode.getStreamId())
                 ? getDownloadUri(podcastEpisode.getStreamId())
                 : MusicUtil.getStreamUri(podcastEpisode.getStreamId());
@@ -232,4 +250,11 @@ public class MappingUtil {
         Download download = new DownloadRepository().getDownload(id);
         return download != null && !download.getDownloadUri().isEmpty() ? Uri.parse(download.getDownloadUri()) : MusicUtil.getDownloadUri(id);
     }
+
+    public static void observeExternalAudioRefresh(LifecycleOwner owner, Runnable onRefresh) {
+        if (owner == null || onRefresh == null) {
+            return;
+        }
+        ExternalAudioReader.getRefreshEvents().observe(owner, event -> onRefresh.run());
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/util/Preferences.kt

@@ -37,6 +37,7 @@ object Preferences {
     private const val WIFI_ONLY = "wifi_only"
     private const val DATA_SAVING_MODE = "data_saving_mode"
     private const val SERVER_UNREACHABLE = "server_unreachable"
+    private const val SYNC_STARRED_ARTISTS_FOR_OFFLINE_USE = "sync_starred_artists_for_offline_use"
     private const val SYNC_STARRED_ALBUMS_FOR_OFFLINE_USE = "sync_starred_albums_for_offline_use"
     private const val SYNC_STARRED_TRACKS_FOR_OFFLINE_USE = "sync_starred_tracks_for_offline_use"
     private const val QUEUE_SYNCING = "queue_syncing"
@@ -45,11 +46,13 @@ object Preferences {
     private const val ROUNDED_CORNER_SIZE = "rounded_corner_size"
     private const val PODCAST_SECTION_VISIBILITY = "podcast_section_visibility"
     private const val RADIO_SECTION_VISIBILITY = "radio_section_visibility"
+    private const val AUTO_DOWNLOAD_LYRICS = "auto_download_lyrics"
     private const val MUSIC_DIRECTORY_SECTION_VISIBILITY = "music_directory_section_visibility"
     private const val REPLAY_GAIN_MODE = "replay_gain_mode"
     private const val AUDIO_TRANSCODE_PRIORITY = "audio_transcode_priority"
     private const val STREAMING_CACHE_STORAGE = "streaming_cache_storage"
     private const val DOWNLOAD_STORAGE = "download_storage"
+    private const val DOWNLOAD_DIRECTORY_URI = "download_directory_uri"
     private const val DEFAULT_DOWNLOAD_VIEW_TYPE = "default_download_view_type"
     private const val AUDIO_TRANSCODE_DOWNLOAD = "audio_transcode_download"
     private const val AUDIO_TRANSCODE_DOWNLOAD_PRIORITY = "audio_transcode_download_priority"
@@ -71,6 +74,9 @@ object Preferences {
     private const val LAST_INSTANT_MIX = "last_instant_mix"
     private const val ALLOW_PLAYLIST_DUPLICATES = "allow_playlist_duplicates"
 
+    private const val EQUALIZER_ENABLED = "equalizer_enabled"
+    private const val EQUALIZER_BAND_LEVELS = "equalizer_band_levels"
+    private const val MINI_SHUFFLE_BUTTON_VISIBILITY = "mini_shuffle_button_visibility"
 
     @JvmStatic
     fun getServer(): String? {
@@ -162,6 +168,24 @@ object Preferences {
         App.getInstance().preferences.edit().putString(OPEN_SUBSONIC_EXTENSIONS, Gson().toJson(extension)).apply()
     }
 
+    @JvmStatic
+    fun isAutoDownloadLyricsEnabled(): Boolean {
+        val preferences = App.getInstance().preferences
+
+        if (preferences.contains(AUTO_DOWNLOAD_LYRICS)) {
+            return preferences.getBoolean(AUTO_DOWNLOAD_LYRICS, false)
+        }
+
+        return false
+    }
+
+    @JvmStatic
+    fun setAutoDownloadLyricsEnabled(isEnabled: Boolean) {
+        App.getInstance().preferences.edit()
+            .putBoolean(AUTO_DOWNLOAD_LYRICS, isEnabled)
+            .apply()
+    }
+
     @JvmStatic
     fun getLocalAddress(): String? {
         return App.getInstance().preferences.getString(LOCAL_ADDRESS, null)
@@ -303,6 +327,18 @@ object Preferences {
                 .apply()
     }
 
+    @JvmStatic
+    fun isStarredArtistsSyncEnabled(): Boolean {
+        return App.getInstance().preferences.getBoolean(SYNC_STARRED_ARTISTS_FOR_OFFLINE_USE, false)
+    }
+
+    @JvmStatic
+    fun setStarredArtistsSyncEnabled(isStarredSyncEnabled: Boolean) {
+        App.getInstance().preferences.edit().putBoolean(
+                SYNC_STARRED_ARTISTS_FOR_OFFLINE_USE, isStarredSyncEnabled
+        ).apply()
+    }
+
     @JvmStatic
     fun isStarredAlbumsSyncEnabled(): Boolean {
         return App.getInstance().preferences.getBoolean(SYNC_STARRED_ALBUMS_FOR_OFFLINE_USE, false)
@@ -327,6 +363,16 @@ object Preferences {
         ).apply()
     }
 
+    @JvmStatic
+    fun showShuffleInsteadOfHeart(): Boolean {
+        return App.getInstance().preferences.getBoolean(MINI_SHUFFLE_BUTTON_VISIBILITY, false)
+    }
+
+    @JvmStatic
+    fun setShuffleInsteadOfHeart(enabled: Boolean) {
+        App.getInstance().preferences.edit().putBoolean(MINI_SHUFFLE_BUTTON_VISIBILITY, enabled).apply()
+    }
+
     @JvmStatic
     fun showServerUnreachableDialog(): Boolean {
         return App.getInstance().preferences.getLong(
@@ -420,6 +466,20 @@ object Preferences {
         ).apply()
     }
 
+    @JvmStatic
+    fun getDownloadDirectoryUri(): String? {
+        return App.getInstance().preferences.getString(DOWNLOAD_DIRECTORY_URI, null)
+    }
+
+    @JvmStatic
+    fun setDownloadDirectoryUri(uri: String?) {
+        val current = App.getInstance().preferences.getString(DOWNLOAD_DIRECTORY_URI, null)
+        if (current != uri) {
+            ExternalDownloadMetadataStore.clear()
+        }
+        App.getInstance().preferences.edit().putString(DOWNLOAD_DIRECTORY_URI, uri).apply()
+    }
+
     @JvmStatic
     fun getDefaultDownloadViewType(): String {
         return App.getInstance().preferences.getString(
@@ -551,5 +611,29 @@ object Preferences {
     @JvmStatic
     fun allowPlaylistDuplicates(): Boolean {
         return App.getInstance().preferences.getBoolean(ALLOW_PLAYLIST_DUPLICATES, false)
+    fun setEqualizerEnabled(enabled: Boolean) {
+        App.getInstance().preferences.edit().putBoolean(EQUALIZER_ENABLED, enabled).apply()
+    }
+
+    @JvmStatic
+    fun isEqualizerEnabled(): Boolean {
+        return App.getInstance().preferences.getBoolean(EQUALIZER_ENABLED, false)
+    }
+
+    @JvmStatic
+    fun setEqualizerBandLevels(bandLevels: ShortArray) {
+        val asString = bandLevels.joinToString(",")
+        App.getInstance().preferences.edit().putString(EQUALIZER_BAND_LEVELS, asString).apply()
+    }
+
+    @JvmStatic
+    fun getEqualizerBandLevels(bandCount: Short): ShortArray {
+        val str = App.getInstance().preferences.getString(EQUALIZER_BAND_LEVELS, null)
+        if (str.isNullOrBlank()) {
+            return ShortArray(bandCount.toInt())
+        }
+        val parts = str.split(",")
+        if (parts.size < bandCount) return ShortArray(bandCount.toInt())
+        return ShortArray(bandCount.toInt()) { i -> parts[i].toShortOrNull() ?: 0 }
     }
 }

app/src/main/java/com/cappielloantonio/tempo/viewmodel/ArtistBottomSheetViewModel.java

@@ -1,17 +1,25 @@
 package com.cappielloantonio.tempo.viewmodel;
 
 import android.app.Application;
-
+import android.content.Context;
+import android.util.Log;
 import androidx.annotation.NonNull;
 import androidx.lifecycle.AndroidViewModel;
 
+import com.cappielloantonio.tempo.model.Download;
 import com.cappielloantonio.tempo.interfaces.StarCallback;
 import com.cappielloantonio.tempo.repository.ArtistRepository;
 import com.cappielloantonio.tempo.repository.FavoriteRepository;
 import com.cappielloantonio.tempo.subsonic.models.ArtistID3;
+import com.cappielloantonio.tempo.subsonic.models.Child;
 import com.cappielloantonio.tempo.util.NetworkUtil;
+import com.cappielloantonio.tempo.util.DownloadUtil;
+import com.cappielloantonio.tempo.util.MappingUtil;
+import com.cappielloantonio.tempo.util.Preferences;
 
 import java.util.Date;
+import java.util.stream.Collectors;
+import java.util.List;
 
 public class ArtistBottomSheetViewModel extends AndroidViewModel {
     private final ArtistRepository artistRepository;
@@ -34,7 +42,7 @@ public class ArtistBottomSheetViewModel extends AndroidViewModel {
         this.artist = artist;
     }
 
-    public void setFavorite() {
+    public void setFavorite(Context context) {
         if (artist.getStarred() != null) {
             if (NetworkUtil.isOffline()) {
                 removeFavoriteOffline();
@@ -43,9 +51,9 @@ public class ArtistBottomSheetViewModel extends AndroidViewModel {
             }
         } else {
             if (NetworkUtil.isOffline()) {
-                setFavoriteOffline();
+                setFavoriteOffline(context);
             } else {
-                setFavoriteOnline();
+                setFavoriteOnline(context);
             }
         }
     }
@@ -59,7 +67,6 @@ public class ArtistBottomSheetViewModel extends AndroidViewModel {
         favoriteRepository.unstar(null, null, artist.getId(), new StarCallback() {
             @Override
             public void onError() {
-                // artist.setStarred(new Date());
                 favoriteRepository.starLater(null, null, artist.getId(), false);
             }
         });
@@ -67,20 +74,45 @@ public class ArtistBottomSheetViewModel extends AndroidViewModel {
         artist.setStarred(null);
     }
 
-    private void setFavoriteOffline() {
+    private void setFavoriteOffline(Context context) {
         favoriteRepository.starLater(null, null, artist.getId(), true);
         artist.setStarred(new Date());
     }
 
-    private void setFavoriteOnline() {
+    private void setFavoriteOnline(Context context) {
         favoriteRepository.star(null, null, artist.getId(), new StarCallback() {
             @Override
             public void onError() {
-                // artist.setStarred(null);
                 favoriteRepository.starLater(null, null, artist.getId(), true);
             }
         });
 
         artist.setStarred(new Date());
+        
+        Log.d("ArtistSync", "Checking preference: " + Preferences.isStarredArtistsSyncEnabled());
+        
+        if (Preferences.isStarredArtistsSyncEnabled()) {
+            Log.d("ArtistSync", "Starting artist sync for: " + artist.getName());
+            
+            artistRepository.getArtistAllSongs(artist.getId(), new ArtistRepository.ArtistSongsCallback() {
+                @Override
+                public void onSongsCollected(List<Child> songs) {
+                    Log.d("ArtistSync", "Callback triggered with songs: " + (songs != null ? songs.size() : 0));
+                    if (songs != null && !songs.isEmpty()) {
+                        Log.d("ArtistSync", "Starting download of " + songs.size() + " songs");
+                        DownloadUtil.getDownloadTracker(context).download(
+                                MappingUtil.mapDownloads(songs),
+                                songs.stream().map(Download::new).collect(Collectors.toList())
+                        );
+                        Log.d("ArtistSync", "Download started successfully");
+                    } else {
+                        Log.d("ArtistSync", "No songs to download");
+                    }
+                }
+            });
+        } else {
+            Log.d("ArtistSync", "Artist sync preference is disabled");
+        }
     }
+    ///
 }

app/src/main/java/com/cappielloantonio/tempo/viewmodel/DownloadViewModel.java

@@ -1,6 +1,7 @@
 package com.cappielloantonio.tempo.viewmodel;
 
 import android.app.Application;
+import android.net.Uri;
 import android.util.Log;
 
 import androidx.annotation.NonNull;
@@ -8,10 +9,13 @@ import androidx.lifecycle.AndroidViewModel;
 import androidx.lifecycle.LifecycleOwner;
 import androidx.lifecycle.LiveData;
 import androidx.lifecycle.MutableLiveData;
+import androidx.documentfile.provider.DocumentFile;
 
+import com.cappielloantonio.tempo.model.Download;
 import com.cappielloantonio.tempo.model.DownloadStack;
 import com.cappielloantonio.tempo.repository.DownloadRepository;
 import com.cappielloantonio.tempo.subsonic.models.Child;
+import com.cappielloantonio.tempo.util.ExternalAudioReader;
 import com.cappielloantonio.tempo.util.Preferences;
 
 import java.util.ArrayList;
@@ -25,6 +29,7 @@ public class DownloadViewModel extends AndroidViewModel {
 
     private final MutableLiveData<List<Child>> downloadedTrackSample = new MutableLiveData<>(null);
     private final MutableLiveData<ArrayList<DownloadStack>> viewStack = new MutableLiveData<>(null);
+    private final MutableLiveData<Integer> refreshResult = new MutableLiveData<>();
 
     public DownloadViewModel(@NonNull Application application) {
         super(application);
@@ -43,6 +48,10 @@ public class DownloadViewModel extends AndroidViewModel {
         return viewStack;
     }
 
+    public LiveData<Integer> getRefreshResult() {
+        return refreshResult;
+    }
+
     public void initViewStack(DownloadStack level) {
         ArrayList<DownloadStack> stack = new ArrayList<>();
         stack.add(level);
@@ -60,4 +69,59 @@ public class DownloadViewModel extends AndroidViewModel {
         stack.remove(stack.size() - 1);
         viewStack.setValue(stack);
     }
+
+    public void refreshExternalDownloads() {
+        new Thread(() -> {
+            String directoryUri = Preferences.getDownloadDirectoryUri();
+            if (directoryUri == null) {
+                refreshResult.postValue(-1);
+                return;
+            }
+
+            List<Download> downloads = downloadRepository.getAllDownloads();
+            if (downloads == null || downloads.isEmpty()) {
+                refreshResult.postValue(0);
+                return;
+            }
+
+            ArrayList<Download> toRemove = new ArrayList<>();
+
+            for (Download download : downloads) {
+                String uriString = download.getDownloadUri();
+                if (uriString == null || uriString.isEmpty()) {
+                    continue;
+                }
+
+                Uri uri = Uri.parse(uriString);
+                if (uri.getScheme() == null || !uri.getScheme().equalsIgnoreCase("content")) {
+                    continue;
+                }
+
+                DocumentFile file;
+                try {
+                    file = DocumentFile.fromSingleUri(getApplication(), uri);
+                } catch (SecurityException exception) {
+                    file = null;
+                }
+
+                if (file == null || !file.exists()) {
+                    toRemove.add(download);
+                }
+            }
+
+            if (!toRemove.isEmpty()) {
+                ArrayList<String> ids = new ArrayList<>();
+                for (Download download : toRemove) {
+                    ids.add(download.getId());
+                    ExternalAudioReader.removeMetadata(download);
+                }
+
+                downloadRepository.delete(ids);
+                ExternalAudioReader.refreshCache();
+                refreshResult.postValue(ids.size());
+            } else {
+                refreshResult.postValue(0);
+            }
+        }).start();
+    }
 }

app/src/main/java/com/cappielloantonio/tempo/viewmodel/HomeViewModel.java

@@ -48,6 +48,7 @@ public class HomeViewModel extends AndroidViewModel {
     private final SharingRepository sharingRepository;
 
     private final StarredAlbumsSyncViewModel albumsSyncViewModel;
+    private final StarredArtistsSyncViewModel artistSyncViewModel;
 
     private final MutableLiveData<List<Child>> dicoverSongSample = new MutableLiveData<>(null);
     private final MutableLiveData<List<AlbumID3>> newReleasedAlbum = new MutableLiveData<>(null);
@@ -85,6 +86,7 @@ public class HomeViewModel extends AndroidViewModel {
         sharingRepository = new SharingRepository();
 
         albumsSyncViewModel = new StarredAlbumsSyncViewModel(application);
+        artistSyncViewModel = new StarredArtistsSyncViewModel(application);
 
         setOfflineFavorite();
     }
@@ -174,6 +176,10 @@ public class HomeViewModel extends AndroidViewModel {
         return albumsSyncViewModel.getAllStarredAlbumSongs();
     }
 
+    public LiveData<List<Child>> getAllStarredArtistSongs() {
+        return artistSyncViewModel.getAllStarredArtistSongs();
+    }
+
     public LiveData<List<ArtistID3>> getStarredArtists(LifecycleOwner owner) {
         if (starredArtists.getValue() == null) {
             artistRepository.getStarredArtists(true, 20).observe(owner, starredArtists::postValue);

app/src/main/java/com/cappielloantonio/tempo/viewmodel/PlaybackViewModel.java

@@ -0,0 +1,35 @@
+package com.cappielloantonio.tempo.viewmodel;
+
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
+import androidx.lifecycle.ViewModel;
+
+import java.util.Objects;
+
+public class PlaybackViewModel extends ViewModel {
+
+    private final MutableLiveData<String> currentSongId = new MutableLiveData<>(null);
+    private final MutableLiveData<Boolean> isPlaying = new MutableLiveData<>(false);
+
+    public LiveData<String> getCurrentSongId() {
+        return currentSongId;
+    }
+
+    public LiveData<Boolean> getIsPlaying() {
+        return isPlaying;
+    }
+
+    public void update(String songId, boolean playing) {
+        if (!Objects.equals(currentSongId.getValue(), songId)) {
+            currentSongId.postValue(songId);
+        }
+        if (!Objects.equals(isPlaying.getValue(), playing)) {
+            isPlaying.postValue(playing);
+        }
+    }
+
+    public void clear() {
+        currentSongId.postValue(null);
+        isPlaying.postValue(false);
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/viewmodel/PlayerBottomSheetViewModel.java

@@ -2,6 +2,7 @@ package com.cappielloantonio.tempo.viewmodel;
 
 import android.app.Application;
 import android.content.Context;
+import android.text.TextUtils;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.OptIn;
@@ -9,14 +10,17 @@ import androidx.lifecycle.AndroidViewModel;
 import androidx.lifecycle.LifecycleOwner;
 import androidx.lifecycle.LiveData;
 import androidx.lifecycle.MutableLiveData;
+import androidx.lifecycle.Observer;
 import androidx.media3.common.util.UnstableApi;
 
 import com.cappielloantonio.tempo.interfaces.StarCallback;
 import com.cappielloantonio.tempo.model.Download;
+import com.cappielloantonio.tempo.model.LyricsCache;
 import com.cappielloantonio.tempo.model.Queue;
 import com.cappielloantonio.tempo.repository.AlbumRepository;
 import com.cappielloantonio.tempo.repository.ArtistRepository;
 import com.cappielloantonio.tempo.repository.FavoriteRepository;
+import com.cappielloantonio.tempo.repository.LyricsRepository;
 import com.cappielloantonio.tempo.repository.OpenRepository;
 import com.cappielloantonio.tempo.repository.QueueRepository;
 import com.cappielloantonio.tempo.repository.SongRepository;
@@ -31,6 +35,7 @@ import com.cappielloantonio.tempo.util.MappingUtil;
 import com.cappielloantonio.tempo.util.NetworkUtil;
 import com.cappielloantonio.tempo.util.OpenSubsonicExtensionsUtil;
 import com.cappielloantonio.tempo.util.Preferences;
+import com.google.gson.Gson;
 
 import java.util.Collections;
 import java.util.Date;
@@ -47,14 +52,20 @@ public class PlayerBottomSheetViewModel extends AndroidViewModel {
     private final QueueRepository queueRepository;
     private final FavoriteRepository favoriteRepository;
     private final OpenRepository openRepository;
+    private final LyricsRepository lyricsRepository;
     private final MutableLiveData<String> lyricsLiveData = new MutableLiveData<>(null);
     private final MutableLiveData<LyricsList> lyricsListLiveData = new MutableLiveData<>(null);
+    private final MutableLiveData<Boolean> lyricsCachedLiveData = new MutableLiveData<>(false);
     private final MutableLiveData<String> descriptionLiveData = new MutableLiveData<>(null);
     private final MutableLiveData<Child> liveMedia = new MutableLiveData<>(null);
     private final MutableLiveData<AlbumID3> liveAlbum = new MutableLiveData<>(null);
     private final MutableLiveData<ArtistID3> liveArtist = new MutableLiveData<>(null);
     private final MutableLiveData<List<Child>> instantMix = new MutableLiveData<>(null);
+    private final Gson gson = new Gson();
     private boolean lyricsSyncState = true;
+    private LiveData<LyricsCache> cachedLyricsSource;
+    private String currentSongId;
+    private final Observer<LyricsCache> cachedLyricsObserver = this::onCachedLyricsChanged;
 
 
     public PlayerBottomSheetViewModel(@NonNull Application application) {
@@ -66,6 +77,7 @@ public class PlayerBottomSheetViewModel extends AndroidViewModel {
         queueRepository = new QueueRepository();
         favoriteRepository = new FavoriteRepository();
         openRepository = new OpenRepository();
+        lyricsRepository = new LyricsRepository();
     }
 
     public LiveData<List<Queue>> getQueueSong() {
@@ -122,7 +134,7 @@ public class PlayerBottomSheetViewModel extends AndroidViewModel {
 
         media.setStarred(new Date());
 
-        if (Preferences.isStarredSyncEnabled()) {
+        if (Preferences.isStarredSyncEnabled() && Preferences.getDownloadDirectoryUri() == null) {
             DownloadUtil.getDownloadTracker(context).download(
                     MappingUtil.mapDownload(media),
                     new Download(media)
@@ -139,12 +151,49 @@ public class PlayerBottomSheetViewModel extends AndroidViewModel {
     }
 
     public void refreshMediaInfo(LifecycleOwner owner, Child media) {
+        lyricsLiveData.postValue(null);
+        lyricsListLiveData.postValue(null);
+        lyricsCachedLiveData.postValue(false);
+
+        clearCachedLyricsObserver();
+
+        String songId = media != null ? media.getId() : currentSongId;
+
+        if (TextUtils.isEmpty(songId) || owner == null) {
+            return;
+        }
+
+        currentSongId = songId;
+
+        observeCachedLyrics(owner, songId);
+
+        LyricsCache cachedLyrics = lyricsRepository.getLyrics(songId);
+        if (cachedLyrics != null) {
+            onCachedLyricsChanged(cachedLyrics);
+        }
+
+        if (NetworkUtil.isOffline() || media == null) {
+            return;
+        }
+
         if (OpenSubsonicExtensionsUtil.isSongLyricsExtensionAvailable()) {
-            openRepository.getLyricsBySongId(media.getId()).observe(owner, lyricsListLiveData::postValue);
-            lyricsLiveData.postValue(null);
+            openRepository.getLyricsBySongId(media.getId()).observe(owner, lyricsList -> {
+                lyricsListLiveData.postValue(lyricsList);
+                lyricsLiveData.postValue(null);
+
+                if (shouldAutoDownloadLyrics() && hasStructuredLyrics(lyricsList)) {
+                    saveLyricsToCache(media, null, lyricsList);
+                }
+            });
         } else {
-            songRepository.getSongLyrics(media).observe(owner, lyricsLiveData::postValue);
-            lyricsListLiveData.postValue(null);
+            songRepository.getSongLyrics(media).observe(owner, lyrics -> {
+                lyricsLiveData.postValue(lyrics);
+                lyricsListLiveData.postValue(null);
+
+                if (shouldAutoDownloadLyrics() && !TextUtils.isEmpty(lyrics)) {
+                    saveLyricsToCache(media, lyrics, null);
+                }
+            });
         }
     }
 
@@ -153,6 +202,17 @@ public class PlayerBottomSheetViewModel extends AndroidViewModel {
     }
 
     public void setLiveMedia(LifecycleOwner owner, String mediaType, String mediaId) {
+        currentSongId = mediaId;
+
+        if (!TextUtils.isEmpty(mediaId)) {
+            refreshMediaInfo(owner, null);
+        } else {
+            clearCachedLyricsObserver();
+            lyricsLiveData.postValue(null);
+            lyricsListLiveData.postValue(null);
+            lyricsCachedLiveData.postValue(false);
+        }
+
         if (mediaType != null) {
             switch (mediaType) {
                 case Constants.MEDIA_TYPE_MUSIC:
@@ -162,7 +222,12 @@ public class PlayerBottomSheetViewModel extends AndroidViewModel {
                 case Constants.MEDIA_TYPE_PODCAST:
                     liveMedia.postValue(null);
                     break;
+                default:
+                    liveMedia.postValue(null);
+                    break;
             }
+        } else {
+            liveMedia.postValue(null);
         }
     }
 
@@ -233,6 +298,105 @@ public class PlayerBottomSheetViewModel extends AndroidViewModel {
         return false;
     }
 
+    private void observeCachedLyrics(LifecycleOwner owner, String songId) {
+        if (TextUtils.isEmpty(songId)) {
+            return;
+        }
+
+        cachedLyricsSource = lyricsRepository.observeLyrics(songId);
+        cachedLyricsSource.observe(owner, cachedLyricsObserver);
+    }
+
+    private void clearCachedLyricsObserver() {
+        if (cachedLyricsSource != null) {
+            cachedLyricsSource.removeObserver(cachedLyricsObserver);
+            cachedLyricsSource = null;
+        }
+    }
+
+    private void onCachedLyricsChanged(LyricsCache lyricsCache) {
+        if (lyricsCache == null) {
+            lyricsCachedLiveData.postValue(false);
+            return;
+        }
+
+        lyricsCachedLiveData.postValue(true);
+
+        if (!TextUtils.isEmpty(lyricsCache.getStructuredLyrics())) {
+            try {
+                LyricsList cachedList = gson.fromJson(lyricsCache.getStructuredLyrics(), LyricsList.class);
+                lyricsListLiveData.postValue(cachedList);
+                lyricsLiveData.postValue(null);
+            } catch (Exception exception) {
+                lyricsListLiveData.postValue(null);
+                lyricsLiveData.postValue(lyricsCache.getLyrics());
+            }
+        } else {
+            lyricsListLiveData.postValue(null);
+            lyricsLiveData.postValue(lyricsCache.getLyrics());
+        }
+    }
+
+    private void saveLyricsToCache(Child media, String lyrics, LyricsList lyricsList) {
+        if (media == null) {
+            return;
+        }
+
+        if ((lyricsList == null || !hasStructuredLyrics(lyricsList)) && TextUtils.isEmpty(lyrics)) {
+            return;
+        }
+
+        LyricsCache lyricsCache = new LyricsCache(media.getId());
+        lyricsCache.setArtist(media.getArtist());
+        lyricsCache.setTitle(media.getTitle());
+        lyricsCache.setUpdatedAt(System.currentTimeMillis());
+
+        if (lyricsList != null && hasStructuredLyrics(lyricsList)) {
+            lyricsCache.setStructuredLyrics(gson.toJson(lyricsList));
+            lyricsCache.setLyrics(null);
+        } else {
+            lyricsCache.setLyrics(lyrics);
+            lyricsCache.setStructuredLyrics(null);
+        }
+
+        lyricsRepository.insert(lyricsCache);
+        lyricsCachedLiveData.postValue(true);
+    }
+
+    private boolean hasStructuredLyrics(LyricsList lyricsList) {
+        return lyricsList != null
+                && lyricsList.getStructuredLyrics() != null
+                && !lyricsList.getStructuredLyrics().isEmpty()
+                && lyricsList.getStructuredLyrics().get(0) != null
+                && lyricsList.getStructuredLyrics().get(0).getLine() != null
+                && !lyricsList.getStructuredLyrics().get(0).getLine().isEmpty();
+    }
+
+    private boolean shouldAutoDownloadLyrics() {
+        return Preferences.isAutoDownloadLyricsEnabled();
+    }
+
+    public boolean downloadCurrentLyrics() {
+        Child media = getLiveMedia().getValue();
+        if (media == null) {
+            return false;
+        }
+
+        LyricsList lyricsList = lyricsListLiveData.getValue();
+        String lyrics = lyricsLiveData.getValue();
+
+        if ((lyricsList == null || !hasStructuredLyrics(lyricsList)) && TextUtils.isEmpty(lyrics)) {
+            return false;
+        }
+
+        saveLyricsToCache(media, lyrics, lyricsList);
+        return true;
+    }
+
+    public LiveData<Boolean> getLyricsCachedState() {
+        return lyricsCachedLiveData;
+    }
+
     public void changeSyncLyricsState() {
         lyricsSyncState = !lyricsSyncState;
     }

app/src/main/java/com/cappielloantonio/tempo/viewmodel/SongBottomSheetViewModel.java

@@ -109,7 +109,7 @@ public class SongBottomSheetViewModel extends AndroidViewModel {
 
         media.setStarred(new Date());
 
-        if (Preferences.isStarredSyncEnabled()) {
+        if (Preferences.isStarredSyncEnabled() && Preferences.getDownloadDirectoryUri() == null) {
             DownloadUtil.getDownloadTracker(context).download(
                     MappingUtil.mapDownload(media),
                     new Download(media)

app/src/main/java/com/cappielloantonio/tempo/viewmodel/StarredArtistsSyncViewModel.java

@@ -0,0 +1,94 @@
+package com.cappielloantonio.tempo.viewmodel;
+
+import android.app.Application;
+import android.app.Activity;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.AndroidViewModel;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.Observer;
+import androidx.lifecycle.MutableLiveData;
+
+import com.cappielloantonio.tempo.repository.ArtistRepository;
+import com.cappielloantonio.tempo.subsonic.models.ArtistID3;
+import com.cappielloantonio.tempo.subsonic.models.Child;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class StarredArtistsSyncViewModel extends AndroidViewModel {
+    private final ArtistRepository artistRepository;
+
+    private final MutableLiveData<List<ArtistID3>> starredArtists = new MutableLiveData<>(null);
+    private final MutableLiveData<List<Child>> starredArtistSongs = new MutableLiveData<>(null);
+
+    public StarredArtistsSyncViewModel(@NonNull Application application) {
+        super(application);
+        artistRepository = new ArtistRepository();
+    }
+
+    public LiveData<List<ArtistID3>> getStarredArtists(LifecycleOwner owner) {
+        artistRepository.getStarredArtists(false, -1).observe(owner, starredArtists::postValue);
+        return starredArtists;
+    }
+
+    public LiveData<List<Child>> getAllStarredArtistSongs() {
+        artistRepository.getStarredArtists(false, -1).observeForever(new Observer<List<ArtistID3>>() {
+            @Override
+            public void onChanged(List<ArtistID3> artists) {
+                if (artists != null && !artists.isEmpty()) {
+                    collectAllArtistSongs(artists, starredArtistSongs::postValue);
+                } else {
+                    starredArtistSongs.postValue(new ArrayList<>());
+                }
+                artistRepository.getStarredArtists(false, -1).removeObserver(this);
+            }
+        });
+        
+        return starredArtistSongs;
+    }
+
+    public LiveData<List<Child>> getStarredArtistSongs(Activity activity) {
+        artistRepository.getStarredArtists(false, -1).observe((LifecycleOwner) activity, artists -> {
+            if (artists != null && !artists.isEmpty()) {
+                collectAllArtistSongs(artists, starredArtistSongs::postValue);
+            } else {
+                starredArtistSongs.postValue(new ArrayList<>());
+            }
+        });
+        return starredArtistSongs;
+    }
+
+    private void collectAllArtistSongs(List<ArtistID3> artists, ArtistSongsCallback callback) {
+        if (artists == null || artists.isEmpty()) {
+            callback.onSongsCollected(new ArrayList<>());
+            return;
+        }
+
+        List<Child> allSongs = new ArrayList<>();
+        AtomicInteger remainingArtists = new AtomicInteger(artists.size());
+        
+        for (ArtistID3 artist : artists) {
+            artistRepository.getArtistAllSongs(artist.getId(), new ArtistRepository.ArtistSongsCallback() {
+                @Override
+                public void onSongsCollected(List<Child> songs) {
+                    if (songs != null) {
+                        allSongs.addAll(songs);
+                    }
+                    
+                    int remaining = remainingArtists.decrementAndGet();
+                    if (remaining == 0) {
+                        callback.onSongsCollected(allSongs);
+                    }
+                }
+            });
+        }
+    }
+
+    private interface ArtistSongsCallback {
+        void onSongsCollected(List<Child> songs);
+    }
+}