Repo created

app/src/degoogled/java/com/cappielloantonio/tempo/service/MediaService.kt

@@ -0,0 +1,561 @@
+package com.cappielloantonio.tempo.service
+
+import android.annotation.SuppressLint
+import android.app.PendingIntent.FLAG_IMMUTABLE
+import android.app.PendingIntent.FLAG_UPDATE_CURRENT
+import android.app.TaskStackBuilder
+import android.content.Intent
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.os.Binder
+import android.os.Bundle
+import android.os.IBinder
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.media3.common.*
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.DefaultLoadControl
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.exoplayer.source.MediaSource
+import androidx.media3.session.*
+import androidx.media3.session.MediaSession.ControllerInfo
+import com.cappielloantonio.tempo.R
+import com.cappielloantonio.tempo.repository.QueueRepository
+import com.cappielloantonio.tempo.ui.activity.MainActivity
+import com.cappielloantonio.tempo.util.AssetLinkUtil
+import com.cappielloantonio.tempo.util.Constants
+import com.cappielloantonio.tempo.util.DownloadUtil
+import com.cappielloantonio.tempo.util.DynamicMediaSourceFactory
+import com.cappielloantonio.tempo.util.MappingUtil
+import com.cappielloantonio.tempo.util.Preferences
+import com.cappielloantonio.tempo.util.ReplayGainUtil
+import com.cappielloantonio.tempo.widget.WidgetUpdateManager
+import com.google.common.collect.ImmutableList
+import com.google.common.util.concurrent.Futures
+import com.google.common.util.concurrent.ListenableFuture
+
+
+@UnstableApi
+class MediaService : MediaLibraryService() {
+    private val librarySessionCallback = CustomMediaLibrarySessionCallback()
+
+    private lateinit var player: ExoPlayer
+    private lateinit var mediaLibrarySession: MediaLibrarySession
+    private lateinit var shuffleCommands: List<CommandButton>
+    private lateinit var repeatCommands: List<CommandButton>
+    private lateinit var networkCallback: CustomNetworkCallback
+    lateinit var equalizerManager: EqualizerManager
+
+    private var customLayout = ImmutableList.of<CommandButton>()
+    private val widgetUpdateHandler = Handler(Looper.getMainLooper())
+    private var widgetUpdateScheduled = false
+    private val widgetUpdateRunnable = object : Runnable {
+        override fun run() {
+            if (!player.isPlaying) {
+                widgetUpdateScheduled = false
+                return
+            }
+            updateWidget()
+            widgetUpdateHandler.postDelayed(this, WIDGET_UPDATE_INTERVAL_MS)
+        }
+    }
+
+    inner class LocalBinder : Binder() {
+        fun getEqualizerManager(): EqualizerManager {
+            return this@MediaService.equalizerManager
+        }
+    }
+
+    private val binder = LocalBinder()
+
+    companion object {
+        private const val CUSTOM_COMMAND_TOGGLE_SHUFFLE_MODE_ON =
+            "android.media3.session.demo.SHUFFLE_ON"
+        private const val CUSTOM_COMMAND_TOGGLE_SHUFFLE_MODE_OFF =
+            "android.media3.session.demo.SHUFFLE_OFF"
+        private const val CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_OFF =
+            "android.media3.session.demo.REPEAT_OFF"
+        private const val CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_ONE =
+            "android.media3.session.demo.REPEAT_ONE"
+        private const val CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_ALL =
+            "android.media3.session.demo.REPEAT_ALL"
+        const val ACTION_BIND_EQUALIZER = "com.cappielloantonio.tempo.service.BIND_EQUALIZER"
+        const val ACTION_EQUALIZER_UPDATED = "com.cappielloantonio.tempo.service.EQUALIZER_UPDATED"
+    }
+
+    fun updateMediaItems() {
+        Log.d("MediaService", "update items");
+        val n = player.mediaItemCount
+        val k = player.currentMediaItemIndex
+        val current = player.currentPosition
+        val items = (0 .. n-1).map{i -> MappingUtil.mapMediaItem(player.getMediaItemAt(i))}
+        player.clearMediaItems()
+        player.setMediaItems(items, k, current)
+    }
+
+    inner class CustomNetworkCallback : ConnectivityManager.NetworkCallback() {
+        var wasWifi = false
+
+        init {
+            val manager = getSystemService(ConnectivityManager::class.java)
+            val network = manager.activeNetwork
+            val capabilities = manager.getNetworkCapabilities(network)
+            if (capabilities != null)
+                wasWifi = capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
+        }
+
+        override fun onCapabilitiesChanged(network : Network, networkCapabilities : NetworkCapabilities) {
+            val isWifi = networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
+            if (isWifi != wasWifi) {
+                wasWifi = isWifi
+                widgetUpdateHandler.post(Runnable {
+                    updateMediaItems()
+                })
+            }
+        }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+
+        initializeCustomCommands()
+        initializePlayer()
+        initializeMediaLibrarySession()
+        restorePlayerFromQueue()
+        initializePlayerListener()
+        initializeEqualizerManager()
+        initializeNetworkListener()
+
+        setPlayer(player)
+    }
+
+    override fun onGetSession(controllerInfo: ControllerInfo): MediaLibrarySession {
+        return mediaLibrarySession
+    }
+
+    override fun onDestroy() {
+        releaseNetworkCallback()
+        equalizerManager.release()
+        stopWidgetUpdates()
+        releasePlayer()
+        super.onDestroy()
+    }
+
+    override fun onBind(intent: Intent?): IBinder? {
+        // Check if the intent is for our custom equalizer binder
+        if (intent?.action == ACTION_BIND_EQUALIZER) {
+            return binder
+        }
+        // Otherwise, handle it as a normal MediaLibraryService connection
+        return super.onBind(intent)
+    }
+
+    private inner class CustomMediaLibrarySessionCallback : MediaLibrarySession.Callback {
+
+        override fun onConnect(
+            session: MediaSession,
+            controller: ControllerInfo
+        ): MediaSession.ConnectionResult {
+            val connectionResult = super.onConnect(session, controller)
+            val availableSessionCommands = connectionResult.availableSessionCommands.buildUpon()
+
+            (shuffleCommands + repeatCommands).forEach { commandButton ->
+                commandButton.sessionCommand?.let { availableSessionCommands.add(it) }
+            }
+
+            customLayout = buildCustomLayout(session.player)
+
+            return MediaSession.ConnectionResult.AcceptedResultBuilder(session)
+                .setAvailableSessionCommands(availableSessionCommands.build())
+                .setAvailablePlayerCommands(connectionResult.availablePlayerCommands)
+                .setCustomLayout(customLayout)
+                .build()
+        }
+
+        override fun onPostConnect(session: MediaSession, controller: ControllerInfo) {
+            if (!customLayout.isEmpty() && controller.controllerVersion != 0) {
+                ignoreFuture(mediaLibrarySession.setCustomLayout(controller, customLayout))
+            }
+        }
+
+        fun buildCustomLayout(player: Player): ImmutableList<CommandButton> {
+            val shuffle = shuffleCommands[if (player.shuffleModeEnabled) 1 else 0]
+            val repeat = when (player.repeatMode) {
+                Player.REPEAT_MODE_ONE -> repeatCommands[1]
+                Player.REPEAT_MODE_ALL -> repeatCommands[2]
+                else -> repeatCommands[0]
+            }
+            return ImmutableList.of(shuffle, repeat)
+        }
+
+        override fun onCustomCommand(
+            session: MediaSession,
+            controller: ControllerInfo,
+            customCommand: SessionCommand,
+            args: Bundle
+        ): ListenableFuture<SessionResult> {
+            when (customCommand.customAction) {
+                CUSTOM_COMMAND_TOGGLE_SHUFFLE_MODE_ON -> player.shuffleModeEnabled = true
+                CUSTOM_COMMAND_TOGGLE_SHUFFLE_MODE_OFF -> player.shuffleModeEnabled = false
+                CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_OFF,
+                CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_ALL,
+                CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_ONE -> {
+                    val nextMode = when (player.repeatMode) {
+                        Player.REPEAT_MODE_ONE -> Player.REPEAT_MODE_ALL
+                        Player.REPEAT_MODE_OFF -> Player.REPEAT_MODE_ONE
+                        else -> Player.REPEAT_MODE_OFF
+                    }
+                    player.repeatMode = nextMode
+                }
+            }
+
+            customLayout = librarySessionCallback.buildCustomLayout(player)
+            session.setCustomLayout(customLayout)
+
+            return Futures.immediateFuture(SessionResult(SessionResult.RESULT_SUCCESS))
+        }
+
+        override fun onAddMediaItems(
+            mediaSession: MediaSession,
+            controller: ControllerInfo,
+            mediaItems: List<MediaItem>
+        ): ListenableFuture<List<MediaItem>> {
+            val updatedMediaItems = mediaItems.map { mediaItem ->
+                val mediaMetadata = mediaItem.mediaMetadata
+
+                val newMetadata = mediaMetadata.buildUpon()
+                    .setArtist(
+                        if (mediaMetadata.artist != null) mediaMetadata.artist
+                        else mediaMetadata.extras?.getString("uri") ?: ""
+                    )
+                    .build()
+
+                mediaItem.buildUpon()
+                    .setUri(mediaItem.requestMetadata.mediaUri)
+                    .setMediaMetadata(newMetadata)
+                    .setMimeType(MimeTypes.BASE_TYPE_AUDIO)
+                    .build()
+            }
+            return Futures.immediateFuture(updatedMediaItems)
+        }
+    }
+
+    private fun initializeCustomCommands() {
+        shuffleCommands = listOf(
+            getShuffleCommandButton(
+                SessionCommand(CUSTOM_COMMAND_TOGGLE_SHUFFLE_MODE_ON, Bundle.EMPTY)
+            ),
+            getShuffleCommandButton(
+                SessionCommand(CUSTOM_COMMAND_TOGGLE_SHUFFLE_MODE_OFF, Bundle.EMPTY)
+            )
+        )
+
+        repeatCommands = listOf(
+            getRepeatCommandButton(
+                SessionCommand(CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_OFF, Bundle.EMPTY)
+            ),
+            getRepeatCommandButton(
+                SessionCommand(CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_ONE, Bundle.EMPTY)
+            ),
+            getRepeatCommandButton(
+                SessionCommand(CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_ALL, Bundle.EMPTY)
+            )
+        )
+
+        customLayout = ImmutableList.of(shuffleCommands[0], repeatCommands[0])
+    }
+
+    private fun initializePlayer() {
+        player = ExoPlayer.Builder(this)
+            .setRenderersFactory(getRenderersFactory())
+            .setMediaSourceFactory(getMediaSourceFactory())
+            .setAudioAttributes(AudioAttributes.DEFAULT, true)
+            .setHandleAudioBecomingNoisy(true)
+            .setWakeMode(C.WAKE_MODE_NETWORK)
+            .setLoadControl(initializeLoadControl())
+            .build()
+
+        player.shuffleModeEnabled = Preferences.isShuffleModeEnabled()
+        player.repeatMode = Preferences.getRepeatMode()
+    }
+
+    private fun initializeEqualizerManager() {
+        equalizerManager = EqualizerManager()
+        val audioSessionId = player.audioSessionId
+        attachEqualizerIfPossible(audioSessionId)
+    }
+
+    private fun initializeMediaLibrarySession() {
+        val sessionActivityPendingIntent =
+            TaskStackBuilder.create(this).run {
+                addNextIntent(Intent(this@MediaService, MainActivity::class.java))
+                getPendingIntent(0, FLAG_IMMUTABLE or FLAG_UPDATE_CURRENT)
+            }
+
+        mediaLibrarySession =
+            MediaLibrarySession.Builder(this, player, librarySessionCallback)
+                .setSessionActivity(sessionActivityPendingIntent)
+                .build()
+
+        if (!customLayout.isEmpty()) {
+            mediaLibrarySession.setCustomLayout(customLayout)
+        }
+    }
+
+    private fun initializeNetworkListener() {
+        networkCallback = CustomNetworkCallback()
+        getSystemService(ConnectivityManager::class.java).registerDefaultNetworkCallback(networkCallback)
+        updateMediaItems()
+    }
+
+    private fun restorePlayerFromQueue() {
+        if (player.mediaItemCount > 0) return
+
+        val queueRepository = QueueRepository()
+        val storedQueue = queueRepository.media
+        if (storedQueue.isNullOrEmpty()) return
+
+        val mediaItems = MappingUtil.mapMediaItems(storedQueue)
+        if (mediaItems.isEmpty()) return
+
+        val lastIndex = try {
+            queueRepository.lastPlayedMediaIndex
+        } catch (_: Exception) {
+            0
+        }.coerceIn(0, mediaItems.size - 1)
+
+        val lastPosition = try {
+            queueRepository.lastPlayedMediaTimestamp
+        } catch (_: Exception) {
+            0L
+        }.let { if (it < 0L) 0L else it }
+
+        player.setMediaItems(mediaItems, lastIndex, lastPosition)
+        player.prepare()
+        updateWidget()
+    }
+
+    private fun initializePlayerListener() {
+        player.addListener(object : Player.Listener {
+            override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
+                if (mediaItem == null) return
+
+                if (reason == Player.MEDIA_ITEM_TRANSITION_REASON_SEEK || reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO) {
+                    MediaManager.setLastPlayedTimestamp(mediaItem)
+                }
+                updateWidget()
+            }
+
+            override fun onTracksChanged(tracks: Tracks) {
+                ReplayGainUtil.setReplayGain(player, tracks)
+                val currentMediaItem = player.currentMediaItem
+                if (currentMediaItem != null && currentMediaItem.mediaMetadata.extras != null) {
+                    MediaManager.scrobble(currentMediaItem, false)
+                }
+
+                if (player.currentMediaItemIndex + 1 == player.mediaItemCount)
+                    MediaManager.continuousPlay(player.currentMediaItem)
+            }
+
+            override fun onIsPlayingChanged(isPlaying: Boolean) {
+                if (!isPlaying) {
+                    MediaManager.setPlayingPausedTimestamp(
+                        player.currentMediaItem,
+                        player.currentPosition
+                    )
+                } else {
+                    MediaManager.scrobble(player.currentMediaItem, false)
+                }
+                if (isPlaying) {
+                    scheduleWidgetUpdates()
+                } else {
+                    stopWidgetUpdates()
+                }
+                updateWidget()
+            }
+
+            override fun onPlaybackStateChanged(playbackState: Int) {
+                super.onPlaybackStateChanged(playbackState)
+                if (!player.hasNextMediaItem() &&
+                    playbackState == Player.STATE_ENDED &&
+                    player.mediaMetadata.extras?.getString("type") == Constants.MEDIA_TYPE_MUSIC
+                ) {
+                    MediaManager.scrobble(player.currentMediaItem, true)
+                    MediaManager.saveChronology(player.currentMediaItem)
+                }
+                updateWidget()
+            }
+
+            override fun onPositionDiscontinuity(
+                oldPosition: Player.PositionInfo,
+                newPosition: Player.PositionInfo,
+                reason: Int
+            ) {
+                super.onPositionDiscontinuity(oldPosition, newPosition, reason)
+
+                if (reason == Player.DISCONTINUITY_REASON_AUTO_TRANSITION) {
+                    if (oldPosition.mediaItem?.mediaMetadata?.extras?.getString("type") == Constants.MEDIA_TYPE_MUSIC) {
+                        MediaManager.scrobble(oldPosition.mediaItem, true)
+                        MediaManager.saveChronology(oldPosition.mediaItem)
+                    }
+
+                    if (newPosition.mediaItem?.mediaMetadata?.extras?.getString("type") == Constants.MEDIA_TYPE_MUSIC) {
+                        MediaManager.setLastPlayedTimestamp(newPosition.mediaItem)
+                    }
+                }
+            }
+
+            override fun onShuffleModeEnabledChanged(shuffleModeEnabled: Boolean) {
+                Preferences.setShuffleModeEnabled(shuffleModeEnabled)
+                customLayout = librarySessionCallback.buildCustomLayout(player)
+                mediaLibrarySession.setCustomLayout(customLayout)
+            }
+
+            override fun onRepeatModeChanged(repeatMode: Int) {
+                Preferences.setRepeatMode(repeatMode)
+                customLayout = librarySessionCallback.buildCustomLayout(player)
+                mediaLibrarySession.setCustomLayout(customLayout)
+            }
+
+            override fun onAudioSessionIdChanged(audioSessionId: Int) {
+                attachEqualizerIfPossible(audioSessionId)
+            }
+        })
+        if (player.isPlaying) {
+            scheduleWidgetUpdates()
+        }
+    }
+
+    private fun setPlayer(player: Player) {
+        mediaLibrarySession.player = player
+    }
+
+    private fun releasePlayer() {
+        player.release()
+        mediaLibrarySession.release()
+    }
+
+    private fun releaseNetworkCallback() {
+        getSystemService(ConnectivityManager::class.java).unregisterNetworkCallback(networkCallback)
+    }
+
+    @SuppressLint("PrivateResource")
+    private fun getShuffleCommandButton(sessionCommand: SessionCommand): CommandButton {
+        val isOn = sessionCommand.customAction == CUSTOM_COMMAND_TOGGLE_SHUFFLE_MODE_ON
+        return CommandButton.Builder()
+            .setDisplayName(
+                getString(
+                    if (isOn) R.string.exo_controls_shuffle_on_description
+                    else R.string.exo_controls_shuffle_off_description
+                )
+            )
+            .setSessionCommand(sessionCommand)
+            .setIconResId(if (isOn) R.drawable.exo_icon_shuffle_off else R.drawable.exo_icon_shuffle_on)
+            .build()
+    }
+
+    @SuppressLint("PrivateResource")
+    private fun getRepeatCommandButton(sessionCommand: SessionCommand): CommandButton {
+        val icon = when (sessionCommand.customAction) {
+            CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_ONE -> R.drawable.exo_icon_repeat_one
+            CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_ALL -> R.drawable.exo_icon_repeat_all
+            else -> R.drawable.exo_icon_repeat_off
+        }
+        val description = when (sessionCommand.customAction) {
+            CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_ONE -> R.string.exo_controls_repeat_one_description
+            CUSTOM_COMMAND_TOGGLE_REPEAT_MODE_ALL -> R.string.exo_controls_repeat_all_description
+            else -> R.string.exo_controls_repeat_off_description
+        }
+        return CommandButton.Builder()
+            .setDisplayName(getString(description))
+            .setSessionCommand(sessionCommand)
+            .setIconResId(icon)
+            .build()
+    }
+
+    private fun ignoreFuture(@Suppress("UNUSED_PARAMETER") customLayout: ListenableFuture<SessionResult>) {
+        /* Do nothing. */
+    }
+
+    private fun initializeLoadControl(): DefaultLoadControl {
+        return DefaultLoadControl.Builder()
+            .setBufferDurationsMs(
+                (DefaultLoadControl.DEFAULT_MIN_BUFFER_MS * Preferences.getBufferingStrategy()).toInt(),
+                (DefaultLoadControl.DEFAULT_MAX_BUFFER_MS * Preferences.getBufferingStrategy()).toInt(),
+                DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_MS,
+                DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS
+            )
+            .build()
+    }
+
+    private fun updateWidget() {
+        val mi = player.currentMediaItem
+        val title = mi?.mediaMetadata?.title?.toString()
+            ?: mi?.mediaMetadata?.extras?.getString("title")
+        val artist = mi?.mediaMetadata?.artist?.toString()
+            ?: mi?.mediaMetadata?.extras?.getString("artist")
+        val album = mi?.mediaMetadata?.albumTitle?.toString()
+            ?: mi?.mediaMetadata?.extras?.getString("album")
+        val extras = mi?.mediaMetadata?.extras
+        val coverId = extras?.getString("coverArtId")
+        val songLink = extras?.getString("assetLinkSong")
+            ?: AssetLinkUtil.buildLink(AssetLinkUtil.TYPE_SONG, extras?.getString("id"))
+        val albumLink = extras?.getString("assetLinkAlbum")
+            ?: AssetLinkUtil.buildLink(AssetLinkUtil.TYPE_ALBUM, extras?.getString("albumId"))
+        val artistLink = extras?.getString("assetLinkArtist")
+            ?: AssetLinkUtil.buildLink(AssetLinkUtil.TYPE_ARTIST, extras?.getString("artistId"))
+        val position = player.currentPosition.takeIf { it != C.TIME_UNSET } ?: 0L
+        val duration = player.duration.takeIf { it != C.TIME_UNSET } ?: 0L
+        WidgetUpdateManager.updateFromState(
+            this,
+            title ?: "",
+            artist ?: "",
+            album ?: "",
+            coverId,
+            player.isPlaying,
+            player.shuffleModeEnabled,
+            player.repeatMode,
+            position,
+            duration,
+            songLink,
+            albumLink,
+            artistLink
+        )
+    }
+
+    private fun scheduleWidgetUpdates() {
+        if (widgetUpdateScheduled) return
+        widgetUpdateHandler.postDelayed(widgetUpdateRunnable, WIDGET_UPDATE_INTERVAL_MS)
+        widgetUpdateScheduled = true
+    }
+
+    private fun stopWidgetUpdates() {
+        if (!widgetUpdateScheduled) return
+        widgetUpdateHandler.removeCallbacks(widgetUpdateRunnable)
+        widgetUpdateScheduled = false
+    }
+
+    private fun attachEqualizerIfPossible(audioSessionId: Int): Boolean {
+        if (audioSessionId == 0 || audioSessionId == -1) return false
+        val attached = equalizerManager.attachToSession(audioSessionId)
+        if (attached) {
+            val enabled = Preferences.isEqualizerEnabled()
+            equalizerManager.setEnabled(enabled)
+            val bands = equalizerManager.getNumberOfBands()
+            val savedLevels = Preferences.getEqualizerBandLevels(bands)
+            for (i in 0 until bands) {
+                equalizerManager.setBandLevel(i.toShort(), savedLevels[i])
+            }
+            sendBroadcast(Intent(ACTION_EQUALIZER_UPDATED))
+        }
+        return attached
+    }
+
+    private fun getRenderersFactory() = DownloadUtil.buildRenderersFactory(this, false)
+
+    private fun getMediaSourceFactory(): MediaSource.Factory = DynamicMediaSourceFactory(this)
+}
+
+private const val WIDGET_UPDATE_INTERVAL_MS = 1000L

app/src/degoogled/java/com/cappielloantonio/tempo/ui/fragment/ToolbarFragment.java

@@ -0,0 +1,65 @@
+package com.cappielloantonio.tempo.ui.fragment;
+
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+import androidx.media3.common.util.UnstableApi;
+
+import com.cappielloantonio.tempo.R;
+import com.cappielloantonio.tempo.databinding.FragmentToolbarBinding;
+import com.cappielloantonio.tempo.ui.activity.MainActivity;
+
+@UnstableApi
+public class ToolbarFragment extends Fragment {
+    private static final String TAG = "ToolbarFragment";
+
+    private FragmentToolbarBinding bind;
+    private MainActivity activity;
+
+    public ToolbarFragment() {
+        // Required empty public constructor
+    }
+
+    @Override
+    public void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setHasOptionsMenu(true);
+    }
+
+    @Override
+    public void onCreateOptionsMenu(@NonNull Menu menu, @NonNull MenuInflater inflater) {
+        super.onCreateOptionsMenu(menu, inflater);
+        inflater.inflate(R.menu.main_page_menu, menu);
+    }
+
+    @Override
+    public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        activity = (MainActivity) getActivity();
+
+        bind = FragmentToolbarBinding.inflate(inflater, container, false);
+        View view = bind.getRoot();
+
+        return view;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(@NonNull MenuItem item) {
+        if (item.getItemId() == R.id.action_search) {
+            activity.navController.navigate(R.id.searchFragment);
+            return true;
+        } else if (item.getItemId() == R.id.action_settings) {
+            activity.navController.navigate(R.id.settingsFragment);
+            return true;
+        }
+
+        return false;
+    }
+}

app/src/degoogled/java/com/cappielloantonio/tempo/util/Flavors.java

@@ -0,0 +1,9 @@
+package com.cappielloantonio.tempo.util;
+
+import android.content.Context;
+
+public class Flavors {
+    public static void initializeCastContext(Context context) {
+
+    }
+}

app/src/degoogled/res/drawable/ic_launcher_foreground.xml

@@ -0,0 +1,54 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="512"
+    android:viewportHeight="512">
+  <group android:scaleX="0.49"
+      android:scaleY="0.49"
+      android:translateX="130.56"
+      android:translateY="130.56">
+
+    <path
+        android:pathData="M512,437.33c0,11.78 -9.56,21.34 -21.34,21.34H21.33C9.55,458.67 0,449.11 0,437.33V96c0,-11.78 9.55,-21.33 21.33,-21.33h469.33c11.78,0 21.34,9.55 21.34,21.33L512,437.33L512,437.33z"
+        android:fillColor="#8CC152"/> <path
+      android:pathData="M512,416.01c0,11.78 -9.56,21.31 -21.34,21.31H21.33C9.55,437.33 0,427.8 0,416.01V74.67c0,-11.78 9.55,-21.34 21.33,-21.34h469.33c11.78,0 21.34,9.56 21.34,21.34L512,416.01L512,416.01z"
+      android:fillColor="#62A43B"/> <path
+      android:pathData="M63.99,160c-5.89,0 -10.66,4.78 -10.66,10.67v149.34c0,5.88 4.77,10.66 10.66,10.66c5.89,0 10.67,-4.78 10.67,-10.66V170.67C74.66,164.78 69.88,160 63.99,160z"
+      android:fillColor="#8CC152"/> <path
+      android:pathData="M74.66,106.67c0,5.89 -4.78,10.66 -10.67,10.66c-5.89,0 -10.66,-4.77 -10.66,-10.66S58.1,96 63.99,96C69.88,96 74.66,100.78 74.66,106.67z"
+      android:fillColor="#E6E9ED"/>
+    <path
+        android:pathData="M74.66,384.01c0,5.88 -4.78,10.66 -10.67,10.66c-5.89,0 -10.66,-4.78 -10.66,-10.66c0,-5.91 4.77,-10.69 10.66,-10.69C69.88,373.33 74.66,378.11 74.66,384.01z"
+        android:fillColor="#E6E9ED"/>
+    <path
+        android:pathData="M448,123.73h-21.34v203.19l-40.31,50.41v0.02c-1.47,1.83 -2.34,4.14 -2.34,6.67c0,5.88 4.78,10.66 10.66,10.66c3.38,0 6.38,-1.56 8.33,-4h0.02l42.66,-53.34l0,0c1.47,-1.81 2.34,-4.13 2.34,-6.66V123.73z"
+        android:fillColor="#E6E9ED"/>
+    <path
+        android:pathData="M437.33,149.33c-11.77,0 -21.33,-9.56 -21.33,-21.33s9.56,-21.33 21.33,-21.33s21.33,9.56 21.33,21.33S449.09,149.33 437.33,149.33z"
+        android:fillColor="#E6E9ED"/>
+    <path
+        android:pathData="M437.33,96c-17.67,0 -32,14.33 -32,32s14.33,32 32,32s32,-14.33 32,-32S455,96 437.33,96zM437.33,138.67c-5.89,0 -10.67,-4.8 -10.67,-10.67c0,-5.88 4.78,-10.67 10.67,-10.67s10.67,4.8 10.67,10.67C448,133.88 443.22,138.67 437.33,138.67z"
+        android:fillColor="#CCD1D9"/>
+    <path
+        android:pathData="M405.33,245.33c0,82.48 -66.86,149.34 -149.33,149.34c-82.47,0 -149.33,-66.86 -149.33,-149.34C106.66,162.86 173.52,96 255.99,96C338.47,96 405.33,162.86 405.33,245.33z"
+        android:fillColor="#434A54"/>
+    <path
+        android:pathData="M266.66,149.33c0,-5.89 -4.77,-10.66 -10.67,-10.66c-58.91,0 -106.66,47.75 -106.66,106.65l0,0c0,5.89 4.77,10.67 10.67,10.67s10.67,-4.78 10.67,-10.67l0,0c0,-22.78 8.88,-44.22 24.99,-60.33c16.12,-16.13 37.55,-25 60.34,-25C261.89,160 266.66,155.22 266.66,149.33z"
+        android:fillColor="#656D78"/>
+    <path
+        android:pathData="M352,234.67c-5.9,0 -10.67,4.77 -10.67,10.66l0,0c0,22.8 -8.88,44.23 -24.98,60.34c-16.13,16.13 -37.56,25 -60.35,25c-5.89,0 -10.66,4.78 -10.66,10.66c0,5.91 4.77,10.69 10.66,10.69c58.91,0 106.66,-47.77 106.66,-106.69C362.65,239.44 357.89,234.67 352,234.67z"
+        android:fillColor="#656D78"/>
+    <path
+        android:pathData="M255.99,288.01c-23.52,0 -42.66,-19.16 -42.66,-42.69c0,-23.52 19.14,-42.66 42.66,-42.66c23.54,0 42.66,19.14 42.66,42.66C298.65,268.86 279.53,288.01 255.99,288.01z"
+        android:fillColor="#FFCE54"/>
+    <path
+        android:pathData="M255.99,192c-29.45,0 -53.33,23.88 -53.33,53.33s23.88,53.34 53.33,53.34c29.46,0 53.34,-23.89 53.34,-53.34S285.45,192 255.99,192zM255.99,277.34c-17.64,0 -32,-14.36 -32,-32.02c0,-17.64 14.36,-32 32,-32c17.65,0 32.01,14.36 32.01,32C288,262.98 273.64,277.34 255.99,277.34z"
+        android:fillColor="#F6BB42"/>
+    <path
+        android:pathData="M266.66,245.33c0,5.89 -4.77,10.67 -10.67,10.67c-5.89,0 -10.66,-4.78 -10.66,-10.67s4.77,-10.66 10.66,-10.66C261.89,234.67 266.66,239.44 266.66,245.33z"
+        android:fillColor="#434A54"/>
+    <path
+        android:pathData="M74.66,234.67H53.33c-5.89,0 -10.66,4.77 -10.66,10.66s4.77,10.67 10.66,10.67h21.34c5.89,0 10.66,-4.78 10.66,-10.67S80.56,234.67 74.66,234.67z"
+        android:fillColor="#434A54"/>
+  </group>
+</vector>

app/src/degoogled/res/drawable/ic_splash_logo.xml

@@ -0,0 +1,53 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="512"
+    android:viewportHeight="512">
+  <group android:scaleX="0.55"
+      android:scaleY="0.55"
+      android:translateX="150.56"
+      android:translateY="150.56">
+  <path
+      android:pathData="M512,437.33c0,11.78 -9.56,21.34 -21.34,21.34H21.33C9.55,458.67 0,449.11 0,437.33V96c0,-11.78 9.55,-21.33 21.33,-21.33h469.33c11.78,0 21.34,9.55 21.34,21.33L512,437.33L512,437.33z"
+      android:fillColor="#8CC152"/> <path
+    android:pathData="M512,416.01c0,11.78 -9.56,21.31 -21.34,21.31H21.33C9.55,437.33 0,427.8 0,416.01V74.67c0,-11.78 9.55,-21.34 21.33,-21.34h469.33c11.78,0 21.34,9.56 21.34,21.34L512,416.01L512,416.01z"
+    android:fillColor="#62A43B"/> <path
+    android:pathData="M63.99,160c-5.89,0 -10.66,4.78 -10.66,10.67v149.34c0,5.88 4.77,10.66 10.66,10.66c5.89,0 10.67,-4.78 10.67,-10.66V170.67C74.66,164.78 69.88,160 63.99,160z"
+    android:fillColor="#8CC152"/> <path
+    android:pathData="M74.66,106.67c0,5.89 -4.78,10.66 -10.67,10.66c-5.89,0 -10.66,-4.77 -10.66,-10.66S58.1,96 63.99,96C69.88,96 74.66,100.78 74.66,106.67z"
+    android:fillColor="#E6E9ED"/>
+  <path
+      android:pathData="M74.66,384.01c0,5.88 -4.78,10.66 -10.67,10.66c-5.89,0 -10.66,-4.78 -10.66,-10.66c0,-5.91 4.77,-10.69 10.66,-10.69C69.88,373.33 74.66,378.11 74.66,384.01z"
+      android:fillColor="#E6E9ED"/>
+  <path
+      android:pathData="M448,123.73h-21.34v203.19l-40.31,50.41v0.02c-1.47,1.83 -2.34,4.14 -2.34,6.67c0,5.88 4.78,10.66 10.66,10.66c3.38,0 6.38,-1.56 8.33,-4h0.02l42.66,-53.34l0,0c1.47,-1.81 2.34,-4.13 2.34,-6.66V123.73z"
+      android:fillColor="#E6E9ED"/>
+  <path
+      android:pathData="M437.33,149.33c-11.77,0 -21.33,-9.56 -21.33,-21.33s9.56,-21.33 21.33,-21.33s21.33,9.56 21.33,21.33S449.09,149.33 437.33,149.33z"
+      android:fillColor="#E6E9ED"/>
+  <path
+      android:pathData="M437.33,96c-17.67,0 -32,14.33 -32,32s14.33,32 32,32s32,-14.33 32,-32S455,96 437.33,96zM437.33,138.67c-5.89,0 -10.67,-4.8 -10.67,-10.67c0,-5.88 4.78,-10.67 10.67,-10.67s10.67,4.8 10.67,10.67C448,133.88 443.22,138.67 437.33,138.67z"
+      android:fillColor="#CCD1D9"/>
+  <path
+      android:pathData="M405.33,245.33c0,82.48 -66.86,149.34 -149.33,149.34c-82.47,0 -149.33,-66.86 -149.33,-149.34C106.66,162.86 173.52,96 255.99,96C338.47,96 405.33,162.86 405.33,245.33z"
+      android:fillColor="#434A54"/>
+  <path
+      android:pathData="M266.66,149.33c0,-5.89 -4.77,-10.66 -10.67,-10.66c-58.91,0 -106.66,47.75 -106.66,106.65l0,0c0,5.89 4.77,10.67 10.67,10.67s10.67,-4.78 10.67,-10.67l0,0c0,-22.78 8.88,-44.22 24.99,-60.33c16.12,-16.13 37.55,-25 60.34,-25C261.89,160 266.66,155.22 266.66,149.33z"
+      android:fillColor="#656D78"/>
+  <path
+      android:pathData="M352,234.67c-5.9,0 -10.67,4.77 -10.67,10.66l0,0c0,22.8 -8.88,44.23 -24.98,60.34c-16.13,16.13 -37.56,25 -60.35,25c-5.89,0 -10.66,4.78 -10.66,10.66c0,5.91 4.77,10.69 10.66,10.69c58.91,0 106.66,-47.77 106.66,-106.69C362.65,239.44 357.89,234.67 352,234.67z"
+      android:fillColor="#656D78"/>
+  <path
+      android:pathData="M255.99,288.01c-23.52,0 -42.66,-19.16 -42.66,-42.69c0,-23.52 19.14,-42.66 42.66,-42.66c23.54,0 42.66,19.14 42.66,42.66C298.65,268.86 279.53,288.01 255.99,288.01z"
+      android:fillColor="#FFCE54"/>
+  <path
+      android:pathData="M255.99,192c-29.45,0 -53.33,23.88 -53.33,53.33s23.88,53.34 53.33,53.34c29.46,0 53.34,-23.89 53.34,-53.34S285.45,192 255.99,192zM255.99,277.34c-17.64,0 -32,-14.36 -32,-32.02c0,-17.64 14.36,-32 32,-32c17.65,0 32.01,14.36 32.01,32C288,262.98 273.64,277.34 255.99,277.34z"
+      android:fillColor="#F6BB42"/>
+  <path
+      android:pathData="M266.66,245.33c0,5.89 -4.77,10.67 -10.67,10.67c-5.89,0 -10.66,-4.78 -10.66,-10.67s4.77,-10.66 10.66,-10.66C261.89,234.67 266.66,239.44 266.66,245.33z"
+      android:fillColor="#434A54"/>
+  <path
+      android:pathData="M74.66,234.67H53.33c-5.89,0 -10.66,4.77 -10.66,10.66s4.77,10.67 10.66,10.67h21.34c5.89,0 10.66,-4.78 10.66,-10.67S80.56,234.67 74.66,234.67z"
+      android:fillColor="#434A54"/>
+  </group>
+</vector>

app/src/degoogled/res/menu/main_page_menu.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto">
+    <item
+        android:id="@+id/action_search"
+        android:icon="@drawable/ic_search"
+        android:title="@string/menu_search_button"
+        app:showAsAction="always" />
+
+    <item
+        android:id="@+id/action_settings"
+        android:icon="@drawable/ic_settings"
+        android:title="@string/menu_settings_button"
+        app:showAsAction="never" />
+</menu>

app/src/degoogled/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+</adaptive-icon>

app/src/degoogled/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+</adaptive-icon>

app/src/degoogled/res/values/ic_launcher_background.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_background">#626A75</color>
+</resources>

app/src/main/AndroidManifest.xml

@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+
+    <application
+        android:name="App"
+        android:allowBackup="false"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:localeConfig="@xml/locale_config"
+        android:networkSecurityConfig="@xml/network_security_config"
+        android:roundIcon="@mipmap/ic_launcher"
+        android:supportsRtl="true"
+        android:theme="@style/AppTheme.SplashScreen"
+        android:usesCleartextTraffic="true">
+
+        <!-- Declare that this session demo supports Android Auto. -->
+        <meta-data
+            android:name="com.google.android.gms.car.application"
+            android:resource="@xml/auto_app_desc" />
+
+        <meta-data
+            android:name="com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME"
+            android:value="androidx.media3.cast.DefaultCastOptionsProvider" />
+
+        <meta-data
+            android:name="androidx.car.app.TintableAttributionIcon"
+            android:resource="@drawable/ic_graphic_eq" />
+
+        <activity
+            android:name=".ui.activity.MainActivity"
+            android:exported="true"
+            android:windowSoftInputMode="adjustPan|adjustResize">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data
+                    android:host="asset"
+                    android:scheme="tempo" />
+            </intent-filter>
+        </activity>
+
+        <service
+            android:name=".service.MediaService"
+            android:exported="true"
+            android:foregroundServiceType="mediaPlayback">
+            <intent-filter>
+                <action android:name="androidx.media3.session.MediaLibraryService" />
+                <action android:name="android.media.browse.MediaBrowserService"/>
+                <action android:name="android.media.action.MEDIA_PLAY_FROM_SEARCH"/>
+            </intent-filter>
+        </service>
+
+        <service
+            android:name=".service.DownloaderService"
+            android:exported="true"
+            android:foregroundServiceType="dataSync">
+            <intent-filter>
+                <action android:name="androidx.media3.exoplayer.downloadService.action.RESTART" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </service>
+
+        <service
+            android:name="androidx.appcompat.app.AppLocalesMetadataHolderService"
+            android:enabled="false"
+            android:exported="false">
+            <meta-data
+                android:name="autoStoreLocales"
+                android:value="true" />
+        </service>
+
+        <receiver
+            android:name=".widget.WidgetProvider4x1"
+            android:exported="false"
+            android:label="@string/widget_label">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE"/>
+            </intent-filter>
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/widget_info"/>
+        </receiver>
+
+
+
+    </application>
+</manifest>

app/src/main/java/com/cappielloantonio/tempo/App.java

@@ -0,0 +1,109 @@
+package com.cappielloantonio.tempo;
+
+import android.app.Application;
+import android.content.Context;
+import android.content.SharedPreferences;
+
+import androidx.annotation.NonNull;
+import androidx.preference.PreferenceManager;
+
+import com.cappielloantonio.tempo.github.Github;
+import com.cappielloantonio.tempo.helper.ThemeHelper;
+import com.cappielloantonio.tempo.subsonic.Subsonic;
+import com.cappielloantonio.tempo.subsonic.SubsonicPreferences;
+import com.cappielloantonio.tempo.util.Preferences;
+
+public class App extends Application {
+    private static App instance;
+    private static Context context;
+    private static Subsonic subsonic;
+    private static Github github;
+    private static SharedPreferences preferences;
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
+        String themePref = sharedPreferences.getString(Preferences.THEME, ThemeHelper.DEFAULT_MODE);
+        ThemeHelper.applyTheme(themePref);
+
+        instance = new App();
+        context = getApplicationContext();
+        preferences = PreferenceManager.getDefaultSharedPreferences(context);
+    }
+
+    public static App getInstance() {
+        if (instance == null) {
+            instance = new App();
+        }
+
+        return instance;
+    }
+
+    public static Context getContext() {
+        if (context == null) {
+            context = getInstance();
+        }
+
+        return context;
+    }
+
+    public static Subsonic getSubsonicClientInstance(boolean override) {
+        if (subsonic == null || override) {
+            subsonic = getSubsonicClient();
+        }
+        return subsonic;
+    }
+
+    public static Github getGithubClientInstance() {
+        if (github == null) {
+            github = new Github();
+        }
+        return github;
+    }
+
+    public SharedPreferences getPreferences() {
+        if (preferences == null) {
+            preferences = PreferenceManager.getDefaultSharedPreferences(context);
+        }
+
+        return preferences;
+    }
+
+    public static void refreshSubsonicClient() {
+        subsonic = getSubsonicClient();
+    }
+
+    private static Subsonic getSubsonicClient() {
+        SubsonicPreferences preferences = getSubsonicPreferences();
+
+        if (preferences.getAuthentication() != null) {
+            if (preferences.getAuthentication().getPassword() != null)
+                Preferences.setPassword(preferences.getAuthentication().getPassword());
+            if (preferences.getAuthentication().getToken() != null)
+                Preferences.setToken(preferences.getAuthentication().getToken());
+            if (preferences.getAuthentication().getSalt() != null)
+                Preferences.setSalt(preferences.getAuthentication().getSalt());
+        }
+
+        return new Subsonic(preferences);
+    }
+
+    @NonNull
+    private static SubsonicPreferences getSubsonicPreferences() {
+        String server = Preferences.getInUseServerAddress();
+        String username = Preferences.getUser();
+        String password = Preferences.getPassword();
+        String token = Preferences.getToken();
+        String salt = Preferences.getSalt();
+        boolean isLowSecurity = Preferences.isLowScurity();
+
+        SubsonicPreferences preferences = new SubsonicPreferences();
+        preferences.setServerUrl(server);
+        preferences.setUsername(username);
+        preferences.setAuthentication(password, token, salt, isLowSecurity);
+
+        return preferences;
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/broadcast/receiver/ConnectivityStatusBroadcastReceiver.java

@@ -0,0 +1,34 @@
+package com.cappielloantonio.tempo.broadcast.receiver;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.net.ConnectivityManager;
+import android.view.View;
+
+import androidx.annotation.OptIn;
+import androidx.media3.common.util.UnstableApi;
+
+import com.cappielloantonio.tempo.ui.activity.MainActivity;
+
+@OptIn(markerClass = UnstableApi.class)
+public class ConnectivityStatusBroadcastReceiver extends BroadcastReceiver {
+    private final MainActivity activity;
+
+    public ConnectivityStatusBroadcastReceiver(MainActivity activity) {
+        this.activity = activity;
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
+            boolean noConnectivity = intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, false);
+
+            if (noConnectivity) {
+                activity.bind.offlineModeTextView.setVisibility(View.VISIBLE);
+            } else {
+                activity.bind.offlineModeTextView.setVisibility(View.GONE);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+package com.cappielloantonio.tempo.database;
+
+import androidx.media3.common.util.UnstableApi;
+import androidx.room.AutoMigration;
+import androidx.room.Database;
+import androidx.room.Room;
+import androidx.room.RoomDatabase;
+import androidx.room.TypeConverters;
+
+import com.cappielloantonio.tempo.App;
+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;
+import com.cappielloantonio.tempo.database.dao.ServerDao;
+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;
+import com.cappielloantonio.tempo.model.SessionMediaItem;
+import com.cappielloantonio.tempo.subsonic.models.Playlist;
+
+@UnstableApi
+@Database(
+        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 {
+    private final static String DB_NAME = "tempo_db";
+    private static AppDatabase instance;
+
+    public static synchronized AppDatabase getInstance() {
+        if (instance == null) {
+            instance = Room.databaseBuilder(App.getContext(), AppDatabase.class, DB_NAME)
+                    .fallbackToDestructiveMigration()
+                    .build();
+        }
+
+        return instance;
+    }
+
+    public abstract QueueDao queueDao();
+
+    public abstract ServerDao serverDao();
+
+    public abstract RecentSearchDao recentSearchDao();
+
+    public abstract DownloadDao downloadDao();
+
+    public abstract ChronologyDao chronologyDao();
+
+    public abstract FavoriteDao favoriteDao();
+
+    public abstract SessionMediaItemDao sessionMediaItemDao();
+
+    public abstract PlaylistDao playlistDao();
+
+    public abstract LyricsDao lyricsDao();
+}

app/src/main/java/com/cappielloantonio/tempo/database/converter/DateConverters.kt

@@ -0,0 +1,16 @@
+package com.cappielloantonio.tempo.database.converter
+
+import androidx.room.TypeConverter
+import java.util.*
+
+class DateConverters {
+    @TypeConverter
+    fun fromTimestamp(value: Long?): Date? {
+        return value?.let { Date(it) }
+    }
+
+    @TypeConverter
+    fun dateToTimestamp(date: Date?): Long? {
+        return date?.time
+    }
+}

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

@@ -0,0 +1,23 @@
+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.Chronology;
+
+import java.util.List;
+
+@Dao
+public interface ChronologyDao {
+    @Query("SELECT * FROM chronology WHERE server == :server GROUP BY id ORDER BY timestamp DESC LIMIT :count")
+    LiveData<List<Chronology>> getLastPlayed(String server, int count);
+
+    @Query("SELECT * FROM chronology WHERE timestamp >= :endDate AND timestamp < :startDate AND server == :server GROUP BY id ORDER BY COUNT(id) DESC LIMIT 20")
+    LiveData<List<Chronology>> getAllFrom(long startDate, long endDate, String server);
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    void insert(Chronology chronologyObject);
+}

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

@@ -0,0 +1,41 @@
+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.Download;
+
+import java.util.List;
+
+@Dao
+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);
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    void insert(Download download);
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    void insertAll(List<Download> downloads);
+
+    @Query("UPDATE download SET download_state = 1 WHERE id = :id")
+    void update(String id);
+
+    @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/FavoriteDao.java

@@ -0,0 +1,26 @@
+package com.cappielloantonio.tempo.database.dao;
+
+import androidx.room.Dao;
+import androidx.room.Delete;
+import androidx.room.Insert;
+import androidx.room.OnConflictStrategy;
+import androidx.room.Query;
+
+import com.cappielloantonio.tempo.model.Favorite;
+
+import java.util.List;
+
+@Dao
+public interface FavoriteDao {
+    @Query("SELECT * FROM favorite")
+    List<Favorite> getAll();
+
+    @Insert(onConflict = OnConflictStrategy.IGNORE)
+    void insert(Favorite favorite);
+
+    @Delete
+    void delete(Favorite favorite);
+
+    @Query("DELETE FROM favorite")
+    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/database/dao/PlaylistDao.java

@@ -0,0 +1,27 @@
+package com.cappielloantonio.tempo.database.dao;
+
+import androidx.lifecycle.LiveData;
+import androidx.room.Dao;
+import androidx.room.Delete;
+import androidx.room.Insert;
+import androidx.room.OnConflictStrategy;
+import androidx.room.Query;
+
+import com.cappielloantonio.tempo.subsonic.models.Playlist;
+
+import java.util.List;
+
+@Dao
+public interface PlaylistDao {
+    // @Query("SELECT * FROM playlist WHERE server=:serverId")
+    // LiveData<List<Playlist>> getAll(String serverId);
+
+    @Query("SELECT * FROM playlist")
+    LiveData<List<Playlist>> getAll();
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    void insert(Playlist playlist);
+
+    @Delete
+    void delete(Playlist playlist);
+}

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

@@ -0,0 +1,44 @@
+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.Queue;
+
+import java.util.List;
+
+@Dao
+public interface QueueDao {
+    @Query("SELECT * FROM queue")
+    LiveData<List<Queue>> getAll();
+
+    @Query("SELECT * FROM queue")
+    List<Queue> getAllSimple();
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    void insert(Queue songQueueObject);
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    void insertAll(List<Queue> songQueueObjects);
+
+    @Query("DELETE FROM queue WHERE queue.track_order=:position")
+    void delete(int position);
+
+    @Query("DELETE FROM queue")
+    void deleteAll();
+
+    @Query("SELECT COUNT(*) FROM queue")
+    int count();
+
+    @Query("UPDATE queue SET last_play=:timestamp WHERE id=:id")
+    void setLastPlay(String id, long timestamp);
+
+    @Query("UPDATE queue SET playing_changed=:timestamp WHERE id=:id")
+    void setPlayingChanged(String id, long timestamp);
+
+    @Query("SELECT * FROM queue ORDER BY last_play DESC LIMIT 1")
+    Queue getLastPlayed();
+}

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

@@ -0,0 +1,23 @@
+package com.cappielloantonio.tempo.database.dao;
+
+import androidx.room.Dao;
+import androidx.room.Delete;
+import androidx.room.Insert;
+import androidx.room.OnConflictStrategy;
+import androidx.room.Query;
+
+import com.cappielloantonio.tempo.model.RecentSearch;
+
+import java.util.List;
+
+@Dao
+public interface RecentSearchDao {
+    @Query("SELECT * FROM recent_search ORDER BY search DESC")
+    List<String> getRecent();
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    void insert(RecentSearch search);
+
+    @Delete
+    void delete(RecentSearch search);
+}

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

@@ -0,0 +1,24 @@
+package com.cappielloantonio.tempo.database.dao;
+
+import androidx.lifecycle.LiveData;
+import androidx.room.Dao;
+import androidx.room.Delete;
+import androidx.room.Insert;
+import androidx.room.OnConflictStrategy;
+import androidx.room.Query;
+
+import com.cappielloantonio.tempo.model.Server;
+
+import java.util.List;
+
+@Dao
+public interface ServerDao {
+    @Query("SELECT * FROM server")
+    LiveData<List<Server>> getAll();
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    void insert(Server server);
+
+    @Delete
+    void delete(Server server);
+}

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

@@ -0,0 +1,29 @@
+package com.cappielloantonio.tempo.database.dao;
+
+import androidx.room.Dao;
+import androidx.room.Insert;
+import androidx.room.OnConflictStrategy;
+import androidx.room.Query;
+
+import com.cappielloantonio.tempo.model.Queue;
+import com.cappielloantonio.tempo.model.SessionMediaItem;
+
+import java.util.List;
+
+@Dao
+public interface SessionMediaItemDao {
+    @Query("SELECT * FROM session_media_item WHERE id = :id")
+    SessionMediaItem get(String id);
+
+    @Query("SELECT * FROM session_media_item WHERE timestamp = :timestamp")
+    List<SessionMediaItem> get(long timestamp);
+
+    @Insert(onConflict = OnConflictStrategy.IGNORE)
+    void insert(SessionMediaItem sessionMediaItem);
+
+    @Insert(onConflict = OnConflictStrategy.IGNORE)
+    void insertAll(List<SessionMediaItem> sessionMediaItems);
+
+    @Query("DELETE FROM session_media_item")
+    void deleteAll();
+}

app/src/main/java/com/cappielloantonio/tempo/github/Github.java

@@ -0,0 +1,29 @@
+package com.cappielloantonio.tempo.github;
+
+import com.cappielloantonio.tempo.github.api.release.ReleaseClient;
+
+public class Github {
+    private static final String OWNER = "eddyizm";
+    private static final String REPO = "Tempus";
+    private ReleaseClient releaseClient;
+
+    public ReleaseClient getReleaseClient() {
+        if (releaseClient == null) {
+            releaseClient = new ReleaseClient(this);
+        }
+
+        return releaseClient;
+    }
+
+    public String getUrl() {
+        return "https://api.github.com/";
+    }
+
+    public static String getOwner() {
+        return OWNER;
+    }
+
+    public static String getRepo() {
+        return REPO;
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/github/GithubRetrofitClient.kt

@@ -0,0 +1,30 @@
+package com.cappielloantonio.tempo.github
+
+import okhttp3.OkHttpClient
+import okhttp3.logging.HttpLoggingInterceptor
+import retrofit2.Retrofit
+import retrofit2.converter.gson.GsonConverterFactory
+
+class GithubRetrofitClient(github: Github) {
+    var retrofit: Retrofit
+
+    init {
+        retrofit = Retrofit.Builder()
+                .baseUrl(github.url)
+                .addConverterFactory(GsonConverterFactory.create())
+                .client(getOkHttpClient())
+                .build()
+    }
+
+    private fun getOkHttpClient(): OkHttpClient {
+        return OkHttpClient.Builder()
+                .addInterceptor(getHttpLoggingInterceptor())
+                .build()
+    }
+
+    private fun getHttpLoggingInterceptor(): HttpLoggingInterceptor {
+        val loggingInterceptor = HttpLoggingInterceptor()
+        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY)
+        return loggingInterceptor
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/github/api/release/ReleaseClient.java

@@ -0,0 +1,24 @@
+package com.cappielloantonio.tempo.github.api.release;
+
+import android.util.Log;
+
+import com.cappielloantonio.tempo.github.Github;
+import com.cappielloantonio.tempo.github.GithubRetrofitClient;
+import com.cappielloantonio.tempo.github.models.LatestRelease;
+
+import retrofit2.Call;
+
+public class ReleaseClient {
+    private static final String TAG = "ReleaseClient";
+
+    private final ReleaseService releaseService;
+
+    public ReleaseClient(Github github) {
+        this.releaseService = new GithubRetrofitClient(github).getRetrofit().create(ReleaseService.class);
+    }
+
+    public Call<LatestRelease> getLatestRelease() {
+        Log.d(TAG, "getLatestRelease()");
+        return releaseService.getLatestRelease(Github.getOwner(), Github.getRepo());
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/github/api/release/ReleaseService.java

@@ -0,0 +1,12 @@
+package com.cappielloantonio.tempo.github.api.release;
+
+import com.cappielloantonio.tempo.github.models.LatestRelease;
+
+import retrofit2.Call;
+import retrofit2.http.GET;
+import retrofit2.http.Path;
+
+public interface ReleaseService {
+    @GET("repos/{owner}/{repo}/releases/latest")
+    Call<LatestRelease> getLatestRelease(@Path("owner") String owner, @Path("repo") String repo);
+}

app/src/main/java/com/cappielloantonio/tempo/github/models/Assets.kt

@@ -0,0 +1,34 @@
+package com.cappielloantonio.tempo.github.models
+
+import androidx.annotation.Keep
+import com.google.gson.annotations.SerializedName
+
+@Keep
+data class Assets(
+        @SerializedName("url")
+        var url: String? = null,
+        @SerializedName("id")
+        var id: Int? = null,
+        @SerializedName("node_id")
+        var nodeId: String? = null,
+        @SerializedName("name")
+        var name: String? = null,
+        @SerializedName("label")
+        var label: String? = null,
+        @SerializedName("uploader")
+        var uploader: Uploader? = Uploader(),
+        @SerializedName("content_type")
+        var contentType: String? = null,
+        @SerializedName("state")
+        var state: String? = null,
+        @SerializedName("size")
+        var size: Int? = null,
+        @SerializedName("download_count")
+        var downloadCount: Int? = null,
+        @SerializedName("created_at")
+        var createdAt: String? = null,
+        @SerializedName("updated_at")
+        var updatedAt: String? = null,
+        @SerializedName("browser_download_url")
+        var browserDownloadUrl: String? = null
+)

app/src/main/java/com/cappielloantonio/tempo/github/models/Author.kt

@@ -0,0 +1,44 @@
+package com.cappielloantonio.tempo.github.models
+
+import androidx.annotation.Keep
+import com.google.gson.annotations.SerializedName
+
+@Keep
+data class Author(
+        @SerializedName("login")
+        var login: String? = null,
+        @SerializedName("id")
+        var id: Int? = null,
+        @SerializedName("node_id")
+        var nodeId: String? = null,
+        @SerializedName("avatar_url")
+        var avatarUrl: String? = null,
+        @SerializedName("gravatar_id")
+        var gravatarId: String? = null,
+        @SerializedName("url")
+        var url: String? = null,
+        @SerializedName("html_url")
+        var htmlUrl: String? = null,
+        @SerializedName("followers_url")
+        var followersUrl: String? = null,
+        @SerializedName("following_url")
+        var followingUrl: String? = null,
+        @SerializedName("gists_url")
+        var gistsUrl: String? = null,
+        @SerializedName("starred_url")
+        var starredUrl: String? = null,
+        @SerializedName("subscriptions_url")
+        var subscriptionsUrl: String? = null,
+        @SerializedName("organizations_url")
+        var organizationsUrl: String? = null,
+        @SerializedName("repos_url")
+        var reposUrl: String? = null,
+        @SerializedName("events_url")
+        var eventsUrl: String? = null,
+        @SerializedName("received_events_url")
+        var receivedEventsUrl: String? = null,
+        @SerializedName("type")
+        var type: String? = null,
+        @SerializedName("site_admin")
+        var siteAdmin: Boolean? = null
+)

app/src/main/java/com/cappielloantonio/tempo/github/models/LatestRelease.kt

@@ -0,0 +1,46 @@
+package com.cappielloantonio.tempo.github.models
+
+import androidx.annotation.Keep
+import com.google.gson.annotations.SerializedName
+
+@Keep
+data class LatestRelease(
+        @SerializedName("url")
+        var url: String? = null,
+        @SerializedName("assets_url")
+        var assetsUrl: String? = null,
+        @SerializedName("upload_url")
+        var uploadUrl: String? = null,
+        @SerializedName("html_url")
+        var htmlUrl: String? = null,
+        @SerializedName("id")
+        var id: Int? = null,
+        @SerializedName("author")
+        var author: Author? = Author(),
+        @SerializedName("node_id")
+        var nodeId: String? = null,
+        @SerializedName("tag_name")
+        var tagName: String? = null,
+        @SerializedName("target_commitish")
+        var targetCommitish: String? = null,
+        @SerializedName("name")
+        var name: String? = null,
+        @SerializedName("draft")
+        var draft: Boolean? = null,
+        @SerializedName("prerelease")
+        var prerelease: Boolean? = null,
+        @SerializedName("created_at")
+        var createdAt: String? = null,
+        @SerializedName("published_at")
+        var publishedAt: String? = null,
+        @SerializedName("assets")
+        var assets: ArrayList<Assets> = arrayListOf(),
+        @SerializedName("tarball_url")
+        var tarballUrl: String? = null,
+        @SerializedName("zipball_url")
+        var zipballUrl: String? = null,
+        @SerializedName("body")
+        var body: String? = null,
+        @SerializedName("reactions")
+        var reactions: Reactions? = Reactions()
+)

app/src/main/java/com/cappielloantonio/tempo/github/models/Reactions.kt

@@ -0,0 +1,28 @@
+package com.cappielloantonio.tempo.github.models
+
+import androidx.annotation.Keep
+import com.google.gson.annotations.SerializedName
+
+@Keep
+data class Reactions(
+        @SerializedName("url")
+        var url: String? = null,
+        @SerializedName("total_count")
+        var totalCount: Int? = null,
+        @SerializedName("+1")
+        var like: Int? = null,
+        @SerializedName("-1")
+        var dislike: Int? = null,
+        @SerializedName("laugh")
+        var laugh: Int? = null,
+        @SerializedName("hooray")
+        var hooray: Int? = null,
+        @SerializedName("confused")
+        var confused: Int? = null,
+        @SerializedName("heart")
+        var heart: Int? = null,
+        @SerializedName("rocket")
+        var rocket: Int? = null,
+        @SerializedName("eyes")
+        var eyes: Int? = null
+)

app/src/main/java/com/cappielloantonio/tempo/github/models/Uploader.kt

@@ -0,0 +1,44 @@
+package com.cappielloantonio.tempo.github.models
+
+import androidx.annotation.Keep
+import com.google.gson.annotations.SerializedName
+
+@Keep
+data class Uploader(
+        @SerializedName("login")
+        var login: String? = null,
+        @SerializedName("id")
+        var id: Int? = null,
+        @SerializedName("node_id")
+        var nodeId: String? = null,
+        @SerializedName("avatar_url")
+        var avatarUrl: String? = null,
+        @SerializedName("gravatar_id")
+        var gravatarId: String? = null,
+        @SerializedName("url")
+        var url: String? = null,
+        @SerializedName("html_url")
+        var htmlUrl: String? = null,
+        @SerializedName("followers_url")
+        var followersUrl: String? = null,
+        @SerializedName("following_url")
+        var followingUrl: String? = null,
+        @SerializedName("gists_url")
+        var gistsUrl: String? = null,
+        @SerializedName("starred_url")
+        var starredUrl: String? = null,
+        @SerializedName("subscriptions_url")
+        var subscriptionsUrl: String? = null,
+        @SerializedName("organizations_url")
+        var organizationsUrl: String? = null,
+        @SerializedName("repos_url")
+        var reposUrl: String? = null,
+        @SerializedName("events_url")
+        var eventsUrl: String? = null,
+        @SerializedName("received_events_url")
+        var receivedEventsUrl: String? = null,
+        @SerializedName("type")
+        var type: String? = null,
+        @SerializedName("site_admin")
+        var siteAdmin: Boolean? = null
+)

app/src/main/java/com/cappielloantonio/tempo/github/utils/UpdateUtil.java

@@ -0,0 +1,32 @@
+package com.cappielloantonio.tempo.github.utils;
+
+import com.cappielloantonio.tempo.BuildConfig;
+import com.cappielloantonio.tempo.github.models.LatestRelease;
+
+public class UpdateUtil {
+
+    public static boolean showUpdateDialog(LatestRelease release) {
+        if (release.getTagName() == null) return false;
+        String remoteTag = release.getTagName().replaceAll("^\\D+", "");
+
+        try {
+            String[] local = BuildConfig.VERSION_NAME.split("\\.");
+            String[] remote = remoteTag.split("\\.");
+
+            for (int i = 0; i < local.length; i++) {
+                int localPart = Integer.parseInt(local[i]);
+                int remotePart = Integer.parseInt(remote[i]);
+
+                if (localPart > remotePart) {
+                    return false;
+                } else if (localPart < remotePart) {
+                    return true;
+                }
+            }
+        } catch (Exception exception) {
+            return false;
+        }
+
+        return false;
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/glide/CustomGlideModule.java

@@ -0,0 +1,32 @@
+package com.cappielloantonio.tempo.glide;
+
+import android.content.Context;
+
+import androidx.annotation.NonNull;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.GlideBuilder;
+import com.bumptech.glide.annotation.GlideModule;
+import com.bumptech.glide.load.DecodeFormat;
+import com.bumptech.glide.load.engine.cache.InternalCacheDiskCacheFactory;
+import com.bumptech.glide.Registry;
+import com.bumptech.glide.module.AppGlideModule;
+import com.bumptech.glide.request.RequestOptions;
+import com.cappielloantonio.tempo.util.Preferences;
+
+import java.io.InputStream;
+
+@GlideModule
+public class CustomGlideModule extends AppGlideModule {
+    @Override
+    public void applyOptions(@NonNull Context context, GlideBuilder builder) {
+        int diskCacheSize = Preferences.getImageCacheSize() * 1024 * 1024;
+        builder.setDiskCache(new InternalCacheDiskCacheFactory(context, "cache", diskCacheSize));
+        builder.setDefaultRequestOptions(new RequestOptions().format(DecodeFormat.PREFER_RGB_565));
+    }
+
+    @Override
+    public void registerComponents(@NonNull Context context, @NonNull Glide glide, @NonNull Registry registry) {
+        registry.replace(String.class, InputStream.class, new IPv6StringLoader.Factory());
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/glide/CustomGlideRequest.java

@@ -0,0 +1,150 @@
+package com.cappielloantonio.tempo.glide;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.drawable.ColorDrawable;
+import android.graphics.drawable.Drawable;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+import androidx.appcompat.content.res.AppCompatResources;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.RequestBuilder;
+import com.bumptech.glide.RequestManager;
+import com.bumptech.glide.load.engine.DiskCacheStrategy;
+import com.bumptech.glide.load.resource.bitmap.CenterCrop;
+import com.bumptech.glide.load.resource.bitmap.RoundedCorners;
+import com.bumptech.glide.load.resource.drawable.DrawableTransitionOptions;
+import com.bumptech.glide.request.RequestOptions;
+import com.bumptech.glide.request.target.CustomTarget;
+import com.bumptech.glide.signature.ObjectKey;
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.R;
+import com.cappielloantonio.tempo.util.Preferences;
+import com.cappielloantonio.tempo.util.Util;
+import com.google.android.material.elevation.SurfaceColors;
+
+import java.util.Map;
+
+public class CustomGlideRequest {
+    private static final String TAG = "CustomGlideRequest";
+
+    public static final int CORNER_RADIUS = Preferences.isCornerRoundingEnabled() ? Preferences.getRoundedCornerSize() : 1;
+
+    public static final DiskCacheStrategy DEFAULT_DISK_CACHE_STRATEGY = DiskCacheStrategy.ALL;
+
+    public enum ResourceType {
+        Unknown,
+        Album,
+        Artist,
+        Folder,
+        Directory,
+        Playlist,
+        Podcast,
+        Radio,
+        Song,
+    }
+
+    public static RequestOptions createRequestOptions(Context context, String item, ResourceType type) {
+        return new RequestOptions()
+                .placeholder(new ColorDrawable(SurfaceColors.SURFACE_5.getColor(context)))
+                .fallback(getPlaceholder(context, type))
+                .error(getPlaceholder(context, type))
+                .diskCacheStrategy(DEFAULT_DISK_CACHE_STRATEGY)
+                .signature(new ObjectKey(item != null ? item : 0))
+                .transform(new CenterCrop(), new RoundedCorners(CustomGlideRequest.CORNER_RADIUS));
+    }
+
+    @Nullable
+    private static Drawable getPlaceholder(Context context, ResourceType type) {
+        switch (type) {
+            case Album:
+                return AppCompatResources.getDrawable(context, R.drawable.ic_placeholder_album);
+            case Artist:
+                return AppCompatResources.getDrawable(context, R.drawable.ic_placeholder_artist);
+            case Folder:
+                return AppCompatResources.getDrawable(context, R.drawable.ic_placeholder_folder);
+            case Directory:
+                return AppCompatResources.getDrawable(context, R.drawable.ic_placeholder_directory);
+            case Playlist:
+                return AppCompatResources.getDrawable(context, R.drawable.ic_placeholder_playlist);
+            case Podcast:
+                return AppCompatResources.getDrawable(context, R.drawable.ic_placeholder_podcast);
+            case Radio:
+                return AppCompatResources.getDrawable(context, R.drawable.ic_placeholder_radio);
+            case Song:
+                return AppCompatResources.getDrawable(context, R.drawable.ic_placeholder_song);
+            default:
+            case Unknown:
+                return new ColorDrawable(SurfaceColors.SURFACE_5.getColor(context));
+        }
+    }
+
+    public static String createUrl(String item, int size) {
+        Map<String, String> params = App.getSubsonicClientInstance(false).getParams();
+
+        StringBuilder uri = new StringBuilder();
+
+        uri.append(App.getSubsonicClientInstance(false).getUrl());
+        uri.append("getCoverArt");
+
+        if (params.containsKey("u") && params.get("u") != null)
+            uri.append("?u=").append(Util.encode(params.get("u")));
+        if (params.containsKey("p") && params.get("p") != null)
+            uri.append("&p=").append(params.get("p"));
+        if (params.containsKey("s") && params.get("s") != null)
+            uri.append("&s=").append(params.get("s"));
+        if (params.containsKey("t") && params.get("t") != null)
+            uri.append("&t=").append(params.get("t"));
+        if (params.containsKey("v") && params.get("v") != null)
+            uri.append("&v=").append(params.get("v"));
+        if (params.containsKey("c") && params.get("c") != null)
+            uri.append("&c=").append(params.get("c"));
+        if (size != -1)
+            uri.append("&size=").append(size);
+
+        uri.append("&id=").append(item);
+
+        Log.d(TAG, "createUrl() " + uri);
+
+        return uri.toString();
+    }
+
+    public static void loadAlbumArtBitmap(Context context,
+                                          String coverId,
+                                          int size,
+                                          CustomTarget<Bitmap> target) {
+        String url = createUrl(coverId, size);
+        Glide.with(context)
+                .asBitmap()
+                .load(url)
+                .apply(createRequestOptions(context, coverId, ResourceType.Album))
+                .into(target);
+    }
+
+    public static class Builder {
+        private final RequestManager requestManager;
+        private String item;
+
+        private Builder(Context context, String item, ResourceType type) {
+            this.requestManager = Glide.with(context);
+
+            if (item != null && !Preferences.isDataSavingMode()) {
+                this.item = createUrl(item, Preferences.getImageSize());
+            }
+
+            requestManager.applyDefaultRequestOptions(createRequestOptions(context, item, type));
+        }
+
+        public static Builder from(Context context, String item, ResourceType type) {
+            return new Builder(context, item, type);
+        }
+
+        public RequestBuilder<Drawable> build() {
+            return requestManager
+                    .load(item)
+                    .transition(DrawableTransitionOptions.withCrossFade());
+        }
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/glide/IPv6StringLoader.java

@@ -0,0 +1,110 @@
+package com.cappielloantonio.tempo.glide;
+
+import androidx.annotation.NonNull;
+
+import com.bumptech.glide.Priority;
+import com.bumptech.glide.load.DataSource;
+import com.bumptech.glide.load.Options;
+import com.bumptech.glide.load.data.DataFetcher;
+import com.bumptech.glide.load.model.ModelLoader;
+import com.bumptech.glide.load.model.ModelLoaderFactory;
+import com.bumptech.glide.load.model.MultiModelLoaderFactory;
+import com.bumptech.glide.signature.ObjectKey;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+public class IPv6StringLoader implements ModelLoader<String, InputStream> {
+    private static final int DEFAULT_TIMEOUT_MS = 2500;
+
+    @Override
+    public boolean handles(@NonNull String model) {
+        return model.startsWith("http://") || model.startsWith("https://");
+    }
+
+    @Override
+    public LoadData<InputStream> buildLoadData(@NonNull String model, int width, int height, @NonNull Options options) {
+        if (!handles(model)) {
+            return null;
+        }
+        return new LoadData<>(new ObjectKey(model), new IPv6StreamFetcher(model));
+    }
+
+    private static class IPv6StreamFetcher implements DataFetcher<InputStream> {
+        private final String model;
+        private InputStream stream;
+        private HttpURLConnection connection;
+
+        IPv6StreamFetcher(String model) {
+            this.model = model;
+        }
+
+        @Override
+        public void loadData(@NonNull Priority priority, @NonNull DataCallback<? super InputStream> callback) {
+            try {
+                URL url = new URL(model);
+                connection = (HttpURLConnection) url.openConnection();
+                connection.setConnectTimeout(DEFAULT_TIMEOUT_MS);
+                connection.setReadTimeout(DEFAULT_TIMEOUT_MS);
+                connection.setUseCaches(true);
+                connection.setDoInput(true);
+                connection.connect();
+
+                if (connection.getResponseCode() / 100 != 2) {
+                    callback.onLoadFailed(new IOException("Request failed with status code: " + connection.getResponseCode()));
+                    return;
+                }
+
+                stream = connection.getInputStream();
+                callback.onDataReady(stream);
+            } catch (IOException e) {
+                callback.onLoadFailed(e);
+            }
+        }
+
+        @Override
+        public void cleanup() {
+            if (stream != null) {
+                try {
+                    stream.close();
+                } catch (IOException ignored) {
+                }
+            }
+            if (connection != null) {
+                connection.disconnect();
+            }
+        }
+
+        @Override
+        public void cancel() {
+            // HttpURLConnection does not provide a direct cancel mechanism.
+        }
+
+        @NonNull
+        @Override
+        public Class<InputStream> getDataClass() {
+            return InputStream.class;
+        }
+
+        @NonNull
+        @Override
+        public DataSource getDataSource() {
+            return DataSource.REMOTE;
+        }
+    }
+
+    public static class Factory implements ModelLoaderFactory<String, InputStream> {
+        @NonNull
+        @Override
+        public ModelLoader<String, InputStream> build(@NonNull MultiModelLoaderFactory multiFactory) {
+            return new IPv6StringLoader();
+        }
+
+        @Override
+        public void teardown() {
+            // No-op
+        }
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/helper/ThemeHelper.java

@@ -0,0 +1,35 @@
+package com.cappielloantonio.tempo.helper;
+
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatDelegate;
+
+public class ThemeHelper {
+    private static final String TAG = "ThemeHelper";
+
+    public static final String LIGHT_MODE = "light";
+    public static final String DARK_MODE = "dark";
+    public static final String DEFAULT_MODE = "default";
+
+    public static void applyTheme(@NonNull String themePref) {
+        switch (themePref) {
+            case LIGHT_MODE: {
+                AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO);
+                break;
+            }
+            case DARK_MODE: {
+                AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES);
+                break;
+            }
+            default: {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM);
+                } else {
+                    AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_AUTO_BATTERY);
+                }
+                break;
+            }
+        }
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/helper/recyclerview/CustomLinearSnapHelper.java

@@ -0,0 +1,24 @@
+package com.cappielloantonio.tempo.helper.recyclerview;
+
+import android.view.View;
+
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.LinearSnapHelper;
+import androidx.recyclerview.widget.RecyclerView;
+
+public class CustomLinearSnapHelper extends LinearSnapHelper {
+    @Override
+    public View findSnapView(RecyclerView.LayoutManager layoutManager) {
+        if (layoutManager instanceof LinearLayoutManager) {
+            LinearLayoutManager linearLayoutManager = (LinearLayoutManager) layoutManager;
+            if (!needToDoSnap(linearLayoutManager)) {
+                return null;
+            }
+        }
+        return super.findSnapView(layoutManager);
+    }
+
+    public boolean needToDoSnap(LinearLayoutManager linearLayoutManager) {
+        return linearLayoutManager.findFirstCompletelyVisibleItemPosition() != 0 && linearLayoutManager.findLastCompletelyVisibleItemPosition() != linearLayoutManager.getItemCount() - 1;
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/helper/recyclerview/DotsIndicatorDecoration.java

@@ -0,0 +1,116 @@
+package com.cappielloantonio.tempo.helper.recyclerview;
+
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.view.View;
+
+import androidx.annotation.ColorInt;
+import androidx.recyclerview.widget.GridLayoutManager;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+
+import org.jetbrains.annotations.NotNull;
+
+public class DotsIndicatorDecoration extends RecyclerView.ItemDecoration {
+    private static final String TAG = "DotsIndicatorDecoration";
+
+    private final int indicatorHeight;
+    private final int indicatorItemPadding;
+    private final int radius;
+
+    private final Paint inactivePaint = new Paint();
+    private final Paint activePaint = new Paint();
+
+    public DotsIndicatorDecoration(int radius, int padding, int indicatorHeight, @ColorInt int colorInactive, @ColorInt int colorActive) {
+        float strokeWidth = Resources.getSystem().getDisplayMetrics().density * 1;
+        this.radius = radius;
+
+        inactivePaint.setStrokeCap(Paint.Cap.ROUND);
+        inactivePaint.setStrokeWidth(strokeWidth);
+        inactivePaint.setStyle(Paint.Style.STROKE);
+        inactivePaint.setAntiAlias(true);
+        inactivePaint.setColor(colorInactive);
+
+        activePaint.setStrokeCap(Paint.Cap.ROUND);
+        activePaint.setStrokeWidth(strokeWidth);
+        activePaint.setStyle(Paint.Style.FILL);
+        activePaint.setAntiAlias(true);
+        activePaint.setColor(colorActive);
+
+        this.indicatorItemPadding = padding;
+        this.indicatorHeight = indicatorHeight;
+    }
+
+    @Override
+    public void onDrawOver(@NotNull Canvas c, @NotNull RecyclerView parent, @NotNull RecyclerView.State state) {
+        super.onDrawOver(c, parent, state);
+
+        if (parent.getAdapter() == null) return;
+
+        int itemCount = (int) Math.ceil((double) parent.getAdapter().getItemCount() / 5);
+
+        if (itemCount <= 1) {
+            return;
+        }
+
+        // center horizontally, calculate width and subtract half from center
+        float totalLength = this.radius * 2 * itemCount;
+        float paddingBetweenItems = Math.max(0, itemCount - 1) * indicatorItemPadding;
+        float indicatorTotalWidth = totalLength + paddingBetweenItems;
+        float indicatorStartX = (parent.getWidth() - indicatorTotalWidth) / 2f;
+
+        // center vertically in the allotted space
+        float indicatorPosY = parent.getHeight() - indicatorHeight - (float) indicatorItemPadding / 4;
+
+        drawInactiveDots(c, indicatorStartX, indicatorPosY, itemCount);
+
+        final int activePosition;
+
+        if (parent.getLayoutManager() instanceof GridLayoutManager) {
+            activePosition = ((GridLayoutManager) parent.getLayoutManager()).findFirstVisibleItemPosition();
+        } else if (parent.getLayoutManager() instanceof LinearLayoutManager) {
+            activePosition = ((LinearLayoutManager) parent.getLayoutManager()).findFirstVisibleItemPosition();
+        } else {
+            // not supported layout manager
+            return;
+        }
+
+        if (activePosition == RecyclerView.NO_POSITION) {
+            return;
+        }
+
+        // find offset of active page if the user is scrolling
+        final View activeChild = parent.getLayoutManager().findViewByPosition(activePosition);
+        if (activeChild == null) {
+            return;
+        }
+
+        drawActiveDot(c, indicatorStartX, indicatorPosY, activePosition);
+    }
+
+    private void drawInactiveDots(Canvas c, float indicatorStartX, float indicatorPosY, int itemCount) {
+        // width of item indicator including padding
+        final float itemWidth = this.radius * 2 + indicatorItemPadding;
+
+        float start = indicatorStartX + radius;
+        for (int i = 0; i < itemCount; i++) {
+            c.drawCircle(start, indicatorPosY, radius, inactivePaint);
+            start += itemWidth;
+        }
+    }
+
+    private void drawActiveDot(Canvas c, float indicatorStartX, float indicatorPosY, int highlightPosition) {
+        // width of item indicator including padding
+        final float itemWidth = this.radius * 2 + indicatorItemPadding;
+        float highlightStart = (float) Math.ceil(indicatorStartX + radius + itemWidth * highlightPosition / 5);
+        c.drawCircle(highlightStart, indicatorPosY, radius, activePaint);
+    }
+
+    @Override
+    public void getItemOffsets(@NotNull Rect outRect, @NotNull View view, @NotNull RecyclerView parent, @NotNull RecyclerView.State state) {
+        super.getItemOffsets(outRect, view, parent, state);
+        outRect.bottom = indicatorHeight;
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/helper/recyclerview/FastScrollbar.java

@@ -0,0 +1,197 @@
+package com.cappielloantonio.tempo.helper.recyclerview;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.content.Context;
+import android.text.TextUtils;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import androidx.annotation.IdRes;
+import androidx.annotation.LayoutRes;
+import androidx.annotation.NonNull;
+import androidx.core.view.ViewCompat;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+
+public class FastScrollbar extends LinearLayout {
+    private static final int BUBBLE_ANIMATION_DURATION = 100;
+    private static final int TRACK_SNAP_RANGE = 5;
+
+    private TextView bubble;
+    private View handle;
+    private RecyclerView recyclerView;
+    private int height;
+    private boolean isInitialized = false;
+    private ObjectAnimator currentAnimator = null;
+
+    private final RecyclerView.OnScrollListener onScrollListener = new RecyclerView.OnScrollListener() {
+        @Override
+        public void onScrolled(@NonNull final RecyclerView recyclerView, final int dx, final int dy) {
+            updateBubbleAndHandlePosition();
+        }
+    };
+
+    public interface BubbleTextGetter {
+        String getTextToShowInBubble(int pos);
+    }
+
+    public FastScrollbar(final Context context, final AttributeSet attrs, final int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        init(context);
+    }
+
+    public FastScrollbar(final Context context) {
+        super(context);
+        init(context);
+    }
+
+    public FastScrollbar(final Context context, final AttributeSet attrs) {
+        super(context, attrs);
+        init(context);
+    }
+
+    protected void init(Context context) {
+        if (isInitialized) return;
+        isInitialized = true;
+        setOrientation(HORIZONTAL);
+        setClipChildren(false);
+    }
+
+    public void setViewsToUse(@LayoutRes int layoutResId, @IdRes int bubbleResId, @IdRes int handleResId) {
+        final LayoutInflater inflater = LayoutInflater.from(getContext());
+        inflater.inflate(layoutResId, this, true);
+        bubble = findViewById(bubbleResId);
+        if (bubble != null) bubble.setVisibility(INVISIBLE);
+        handle = findViewById(handleResId);
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+        height = h;
+        updateBubbleAndHandlePosition();
+    }
+
+    @Override
+    public boolean onTouchEvent(@NonNull MotionEvent event) {
+        final int action = event.getAction();
+        switch (action) {
+            case MotionEvent.ACTION_DOWN:
+                if (event.getX() < handle.getX() - ViewCompat.getPaddingStart(handle)) return false;
+                if (currentAnimator != null) currentAnimator.cancel();
+                if (bubble != null && bubble.getVisibility() == INVISIBLE) showBubble();
+                handle.setSelected(true);
+            case MotionEvent.ACTION_MOVE:
+                final float y = event.getY();
+                setBubbleAndHandlePosition(y);
+                setRecyclerViewPosition(y);
+                return true;
+            case MotionEvent.ACTION_UP:
+            case MotionEvent.ACTION_CANCEL:
+                handle.setSelected(false);
+                hideBubble();
+                return true;
+        }
+        return super.onTouchEvent(event);
+    }
+
+    public void setRecyclerView(final RecyclerView recyclerView) {
+        if (this.recyclerView != recyclerView) {
+            if (this.recyclerView != null)
+                this.recyclerView.removeOnScrollListener(onScrollListener);
+            this.recyclerView = recyclerView;
+            if (this.recyclerView == null) return;
+            recyclerView.addOnScrollListener(onScrollListener);
+        }
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        if (recyclerView != null) {
+            recyclerView.removeOnScrollListener(onScrollListener);
+            recyclerView = null;
+        }
+    }
+
+    private void setRecyclerViewPosition(float y) {
+        if (recyclerView != null) {
+            final int itemCount = recyclerView.getAdapter().getItemCount();
+            float proportion;
+            if (handle.getY() == 0) proportion = 0f;
+            else if (handle.getY() + handle.getHeight() >= height - TRACK_SNAP_RANGE)
+                proportion = 1f;
+            else proportion = y / (float) height;
+            final int targetPos = getValueInRange(0, itemCount - 1, (int) (proportion * (float) itemCount));
+            ((LinearLayoutManager) recyclerView.getLayoutManager()).scrollToPositionWithOffset(targetPos, 0);
+            final String bubbleText = ((BubbleTextGetter) recyclerView.getAdapter()).getTextToShowInBubble(targetPos);
+            if (bubble != null) {
+                bubble.setText(bubbleText);
+                if (TextUtils.isEmpty(bubbleText)) {
+                    hideBubble();
+                } else if (bubble.getVisibility() == View.INVISIBLE) {
+                    showBubble();
+                }
+            }
+        }
+    }
+
+    private int getValueInRange(int min, int max, int value) {
+        int minimum = Math.max(min, value);
+        return Math.min(minimum, max);
+    }
+
+    private void updateBubbleAndHandlePosition() {
+        if (bubble == null || handle.isSelected()) return;
+
+        final int verticalScrollOffset = recyclerView.computeVerticalScrollOffset();
+        final int verticalScrollRange = recyclerView.computeVerticalScrollRange();
+        float proportion = (float) verticalScrollOffset / ((float) verticalScrollRange - height);
+        setBubbleAndHandlePosition(height * proportion);
+    }
+
+    private void setBubbleAndHandlePosition(float y) {
+        final int handleHeight = handle.getHeight();
+        handle.setY(getValueInRange(0, height - handleHeight, (int) (y - handleHeight / 2)));
+        if (bubble != null) {
+            int bubbleHeight = bubble.getHeight();
+            bubble.setY(getValueInRange(0, height - bubbleHeight - handleHeight / 2, (int) (y - bubbleHeight)));
+        }
+    }
+
+    private void showBubble() {
+        if (bubble == null) return;
+        bubble.setVisibility(VISIBLE);
+        if (currentAnimator != null) currentAnimator.cancel();
+        currentAnimator = ObjectAnimator.ofFloat(bubble, "alpha", 0f, 1f).setDuration(BUBBLE_ANIMATION_DURATION);
+        currentAnimator.start();
+    }
+
+    private void hideBubble() {
+        if (bubble == null) return;
+        if (currentAnimator != null) currentAnimator.cancel();
+        currentAnimator = ObjectAnimator.ofFloat(bubble, "alpha", 1f, 0f).setDuration(BUBBLE_ANIMATION_DURATION);
+        currentAnimator.addListener(new AnimatorListenerAdapter() {
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                super.onAnimationEnd(animation);
+                bubble.setVisibility(INVISIBLE);
+                currentAnimator = null;
+            }
+
+            @Override
+            public void onAnimationCancel(Animator animation) {
+                super.onAnimationCancel(animation);
+                bubble.setVisibility(INVISIBLE);
+                currentAnimator = null;
+            }
+        });
+        currentAnimator.start();
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/helper/recyclerview/GridItemDecoration.java

@@ -0,0 +1,41 @@
+package com.cappielloantonio.tempo.helper.recyclerview;
+
+import android.graphics.Rect;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+
+public class GridItemDecoration extends RecyclerView.ItemDecoration {
+    private final int spanCount;
+    private final int spacing;
+    private final boolean includeEdge;
+
+    public GridItemDecoration(int spanCount, int spacing, boolean includeEdge) {
+        this.spanCount = spanCount;
+        this.spacing = spacing;
+        this.includeEdge = includeEdge;
+    }
+
+    @Override
+    public void getItemOffsets(@NonNull Rect outRect, @NonNull View view, RecyclerView parent, @NonNull RecyclerView.State state) {
+        int position = parent.getChildAdapterPosition(view); // item position
+        int column = position % spanCount; // item column
+
+        if (includeEdge) {
+            outRect.left = spacing - column * spacing / spanCount; // spacing - column * ((1f / spanCount) * spacing)
+            outRect.right = (column + 1) * spacing / spanCount; // (column + 1) * ((1f / spanCount) * spacing)
+
+            if (position < spanCount) { // top edge
+                outRect.top = spacing;
+            }
+            outRect.bottom = spacing; // item bottom
+        } else {
+            outRect.left = column * spacing / spanCount; // column * ((1f / spanCount) * spacing)
+            outRect.right = spacing - (column + 1) * spacing / spanCount; // spacing - (column + 1) * ((1f /    spanCount) * spacing)
+            if (position >= spanCount) {
+                outRect.top = spacing; // item top
+            }
+        }
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/helper/recyclerview/NestedScrollableHost.kt

@@ -0,0 +1,88 @@
+package com.cappielloantonio.tempo.helper.recyclerview
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewConfiguration
+import android.widget.FrameLayout
+import androidx.viewpager2.widget.ViewPager2
+import androidx.viewpager2.widget.ViewPager2.ORIENTATION_HORIZONTAL
+import kotlin.math.absoluteValue
+import kotlin.math.sign
+
+class NestedScrollableHost : FrameLayout {
+    constructor(context: Context) : super(context)
+    constructor(context: Context, attrs: AttributeSet?) : super(context, attrs)
+
+    private var touchSlop = 0
+    private var initialX = 0f
+    private var initialY = 0f
+    private val parentViewPager: ViewPager2?
+        get() {
+            var v: View? = parent as? View
+            while (v != null && v !is ViewPager2) {
+                v = v.parent as? View
+            }
+            return v as? ViewPager2
+        }
+
+    private val child: View? get() = if (childCount > 0) getChildAt(0) else null
+
+    init {
+        touchSlop = ViewConfiguration.get(context).scaledTouchSlop
+    }
+
+    private fun canChildScroll(orientation: Int, delta: Float): Boolean {
+        val direction = -delta.sign.toInt()
+        return when (orientation) {
+            0 -> child?.canScrollHorizontally(direction) ?: false
+            1 -> child?.canScrollVertically(direction) ?: false
+            else -> throw IllegalArgumentException()
+        }
+    }
+
+    override fun onInterceptTouchEvent(e: MotionEvent): Boolean {
+        handleInterceptTouchEvent(e)
+        return super.onInterceptTouchEvent(e)
+    }
+
+    private fun handleInterceptTouchEvent(e: MotionEvent) {
+        val orientation = parentViewPager?.orientation ?: return
+
+        // Early return if child can't scroll in same direction as parent
+        if (!canChildScroll(orientation, -1f) && !canChildScroll(orientation, 1f)) {
+            return
+        }
+
+        if (e.action == MotionEvent.ACTION_DOWN) {
+            initialX = e.x
+            initialY = e.y
+            parent.requestDisallowInterceptTouchEvent(true)
+        } else if (e.action == MotionEvent.ACTION_MOVE) {
+            val dx = e.x - initialX
+            val dy = e.y - initialY
+            val isVpHorizontal = orientation == ORIENTATION_HORIZONTAL
+
+            // assuming ViewPager2 touch-slop is 2x touch-slop of child
+            val scaledDx = dx.absoluteValue * if (isVpHorizontal) .5f else 1f
+            val scaledDy = dy.absoluteValue * if (isVpHorizontal) 1f else .5f
+
+            if (scaledDx > touchSlop || scaledDy > touchSlop) {
+                if (isVpHorizontal == (scaledDy > scaledDx)) {
+                    // Gesture is perpendicular, allow all parents to intercept
+                    parent.requestDisallowInterceptTouchEvent(false)
+                } else {
+                    // Gesture is parallel, query child if movement in that direction is possible
+                    if (canChildScroll(orientation, if (isVpHorizontal) dx else dy)) {
+                        // Child can scroll, disallow all parents to intercept
+                        parent.requestDisallowInterceptTouchEvent(true)
+                    } else {
+                        // Child cannot scroll, allow all parents to intercept
+                        parent.requestDisallowInterceptTouchEvent(false)
+                    }
+                }
+            }
+        }
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/helper/recyclerview/PaginationScrollListener.java

@@ -0,0 +1,33 @@
+package com.cappielloantonio.tempo.helper.recyclerview;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+
+
+public abstract class PaginationScrollListener extends RecyclerView.OnScrollListener {
+    private final LinearLayoutManager layoutManager;
+
+    protected PaginationScrollListener(LinearLayoutManager layoutManager) {
+        this.layoutManager = layoutManager;
+    }
+
+    @Override
+    public void onScrolled(@NonNull RecyclerView recyclerView, int dx, int dy) {
+        super.onScrolled(recyclerView, dx, dy);
+
+        int visibleItemCount = layoutManager.getChildCount();
+        int totalItemCount = layoutManager.getItemCount();
+        int firstVisibleItemPosition = layoutManager.findFirstVisibleItemPosition();
+
+        if (!isLoading()) {
+            if (firstVisibleItemPosition >= 0 && (visibleItemCount + firstVisibleItemPosition) >= (totalItemCount / 4 * 3)) {
+                loadMoreItems();
+            }
+        }
+    }
+
+    protected abstract void loadMoreItems();
+
+    public abstract boolean isLoading();
+}

app/src/main/java/com/cappielloantonio/tempo/helper/recyclerview/SquareLayout.java

@@ -0,0 +1,28 @@
+package com.cappielloantonio.tempo.helper.recyclerview;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.widget.RelativeLayout;
+
+public class SquareLayout extends RelativeLayout {
+    public SquareLayout(Context context) {
+        super(context);
+    }
+
+    public SquareLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public SquareLayout(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+    public SquareLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        super.onMeasure(widthMeasureSpec, widthMeasureSpec);
+    }
+}

app/src/main/java/com/cappielloantonio/tempo/interfaces/ClickCallback.java

@@ -0,0 +1,35 @@
+package com.cappielloantonio.tempo.interfaces;
+
+
+import android.os.Bundle;
+
+import androidx.annotation.Keep;
+
+@Keep
+public interface ClickCallback {
+    default void onMediaClick(Bundle bundle) {}
+    default void onMediaLongClick(Bundle bundle) {}
+    default void onAlbumClick(Bundle bundle) {}
+    default void onAlbumLongClick(Bundle bundle) {}
+    default void onArtistClick(Bundle bundle) {}
+    default void onArtistLongClick(Bundle bundle) {}
+    default void onGenreClick(Bundle bundle) {}
+    default void onPlaylistClick(Bundle bundle) {}
+    default void onPlaylistLongClick(Bundle bundle) {}
+    default void onYearClick(Bundle bundle) {}
+    default void onServerClick(Bundle bundle) {}
+    default void onServerLongClick(Bundle bundle) {}
+    default void onPodcastEpisodeClick(Bundle bundle) {}
+    default void onPodcastEpisodeAltClick(Bundle bundle) {}
+    default void onPodcastEpisodeLongClick(Bundle bundle) {}
+    default void onPodcastChannelClick(Bundle bundle) {}
+    default void onPodcastChannelLongClick(Bundle bundle) {}
+    default void onInternetRadioStationClick(Bundle bundle) {}
+    default void onInternetRadioStationLongClick(Bundle bundle) {}
+    default void onMusicFolderClick(Bundle bundle) {}
+    default void onMusicDirectoryClick(Bundle bundle) {}
+    default void onMusicIndexClick(Bundle bundle) {}
+    default void onDownloadGroupLongClick(Bundle bundle) {}
+    default void onShareClick(Bundle bundle) {}
+    default void onShareLongClick(Bundle bundle) {}
+}

app/src/main/java/com/cappielloantonio/tempo/interfaces/DecadesCallback.java

@@ -0,0 +1,8 @@
+package com.cappielloantonio.tempo.interfaces;
+
+import androidx.annotation.Keep;
+
+@Keep
+public interface DecadesCallback {
+    default void onLoadYear(int year) {}
+}

app/src/main/java/com/cappielloantonio/tempo/interfaces/DialogClickCallback.java

@@ -0,0 +1,13 @@
+package com.cappielloantonio.tempo.interfaces;
+
+
+import androidx.annotation.Keep;
+
+@Keep
+public interface DialogClickCallback {
+    default void onPositiveClick() {}
+
+    default void onNegativeClick() {}
+
+    default void onNeutralClick() {}
+}

app/src/main/java/com/cappielloantonio/tempo/interfaces/MediaCallback.java

@@ -0,0 +1,11 @@
+package com.cappielloantonio.tempo.interfaces;
+
+import androidx.annotation.Keep;
+
+import java.util.List;
+
+@Keep
+public interface MediaCallback {
+    default void onError(Exception exception) {}
+    default void onLoadMedia(List<?> media) {}
+}

app/src/main/java/com/cappielloantonio/tempo/interfaces/MediaIndexCallback.java

@@ -0,0 +1,8 @@
+package com.cappielloantonio.tempo.interfaces;
+
+import androidx.annotation.Keep;
+
+@Keep
+public interface MediaIndexCallback {
+    default void onRecovery(int index) {}
+}

app/src/main/java/com/cappielloantonio/tempo/interfaces/PlaylistCallback.java

@@ -0,0 +1,8 @@
+package com.cappielloantonio.tempo.interfaces;
+
+import androidx.annotation.Keep;
+
+@Keep
+public interface PlaylistCallback {
+    default void onDismiss() {}
+}

app/src/main/java/com/cappielloantonio/tempo/interfaces/PodcastCallback.java

@@ -0,0 +1,9 @@
+package com.cappielloantonio.tempo.interfaces;
+
+import androidx.annotation.Keep;
+
+@Keep
+
+public interface PodcastCallback {
+    default void onDismiss() {}
+}

app/src/main/java/com/cappielloantonio/tempo/interfaces/RadioCallback.java

@@ -0,0 +1,9 @@
+package com.cappielloantonio.tempo.interfaces;
+
+import androidx.annotation.Keep;
+
+@Keep
+
+public interface RadioCallback {
+    default void onDismiss() {}
+}

app/src/main/java/com/cappielloantonio/tempo/interfaces/ScanCallback.java

@@ -0,0 +1,9 @@
+package com.cappielloantonio.tempo.interfaces;
+
+import androidx.annotation.Keep;
+
+@Keep
+public interface ScanCallback {
+    default void onError(Exception exception) {}
+    default void onSuccess(boolean isScanning, long count) {}
+}

app/src/main/java/com/cappielloantonio/tempo/interfaces/StarCallback.java

@@ -0,0 +1,9 @@
+package com.cappielloantonio.tempo.interfaces;
+
+import androidx.annotation.Keep;
+
+@Keep
+public interface StarCallback {
+    default void onError() {}
+    default void onSuccess() {}
+}

app/src/main/java/com/cappielloantonio/tempo/interfaces/SystemCallback.java

@@ -0,0 +1,9 @@
+package com.cappielloantonio.tempo.interfaces;
+
+import androidx.annotation.Keep;
+
+@Keep
+public interface SystemCallback {
+    default void onError(Exception exception) {}
+    default void onSuccess(String password, String token, String salt) {}
+}

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

@@ -0,0 +1,59 @@
+package com.cappielloantonio.tempo.model
+
+import androidx.annotation.Keep
+import androidx.media3.common.MediaItem
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.cappielloantonio.tempo.subsonic.models.Child
+import com.cappielloantonio.tempo.util.Preferences
+import kotlinx.parcelize.Parcelize
+import java.util.Date
+
+@Keep
+@Parcelize
+@Entity(tableName = "chronology")
+class Chronology(
+    @PrimaryKey override val id: String,
+    @ColumnInfo(name = "timestamp")
+    var timestamp: Long = System.currentTimeMillis(),
+    @ColumnInfo(name = "server")
+    var server: String? = null,
+) : Child(id) {
+    constructor(mediaItem: MediaItem) : this(mediaItem.mediaMetadata.extras!!.getString("id")!!) {
+        parentId = mediaItem.mediaMetadata.extras!!.getString("parentId")
+        isDir = mediaItem.mediaMetadata.extras!!.getBoolean("isDir")
+        title = mediaItem.mediaMetadata.extras!!.getString("title")
+        album = mediaItem.mediaMetadata.extras!!.getString("album")
+        artist = mediaItem.mediaMetadata.extras!!.getString("artist")
+        track = mediaItem.mediaMetadata.extras!!.getInt("track")
+        year = mediaItem.mediaMetadata.extras!!.getInt("year")
+        genre = mediaItem.mediaMetadata.extras!!.getString("genre")
+        coverArtId = mediaItem.mediaMetadata.extras!!.getString("coverArtId")
+        size = mediaItem.mediaMetadata.extras!!.getLong("size")
+        contentType = mediaItem.mediaMetadata.extras!!.getString("contentType")
+        suffix = mediaItem.mediaMetadata.extras!!.getString("suffix")
+        transcodedContentType = mediaItem.mediaMetadata.extras!!.getString("transcodedContentType")
+        transcodedSuffix = mediaItem.mediaMetadata.extras!!.getString("transcodedSuffix")
+        duration = mediaItem.mediaMetadata.extras!!.getInt("duration")
+        bitrate = mediaItem.mediaMetadata.extras!!.getInt("bitrate")
+        samplingRate = mediaItem.mediaMetadata.extras!!.getInt("samplingRate")
+        bitDepth = mediaItem.mediaMetadata.extras!!.getInt("bitDepth")
+        path = mediaItem.mediaMetadata.extras!!.getString("path")
+        isVideo = mediaItem.mediaMetadata.extras!!.getBoolean("isVideo")
+        userRating = mediaItem.mediaMetadata.extras!!.getInt("userRating")
+        averageRating = mediaItem.mediaMetadata.extras!!.getDouble("averageRating")
+        playCount = mediaItem.mediaMetadata.extras!!.getLong("playCount")
+        discNumber = mediaItem.mediaMetadata.extras!!.getInt("discNumber")
+        created = Date(mediaItem.mediaMetadata.extras!!.getLong("created"))
+        starred = Date(mediaItem.mediaMetadata.extras!!.getLong("starred"))
+        albumId = mediaItem.mediaMetadata.extras!!.getString("albumId")
+        artistId = mediaItem.mediaMetadata.extras!!.getString("artistId")
+        type = mediaItem.mediaMetadata.extras!!.getString("type")
+        bookmarkPosition = mediaItem.mediaMetadata.extras!!.getLong("bookmarkPosition")
+        originalWidth = mediaItem.mediaMetadata.extras!!.getInt("originalWidth")
+        originalHeight = mediaItem.mediaMetadata.extras!!.getInt("originalHeight")
+        server = Preferences.getServerId()
+        timestamp = Date().time
+    }
+}

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

@@ -0,0 +1,64 @@
+package com.cappielloantonio.tempo.model
+
+import androidx.annotation.Keep
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.cappielloantonio.tempo.subsonic.models.Child
+import kotlinx.parcelize.Parcelize
+
+@Keep
+@Parcelize
+@Entity(tableName = "download")
+class Download(
+    @PrimaryKey override val id: String,
+    @ColumnInfo(name = "playlist_id")
+    var playlistId: String? = null,
+    @ColumnInfo(name = "playlist_name")
+    var playlistName: String? = null,
+    @ColumnInfo(name = "download_state", defaultValue = "1")
+    var downloadState: Int = 0,
+    @ColumnInfo(name = "download_uri", defaultValue = "")
+    var downloadUri: String? = null,
+) : Child(id) {
+    constructor(child: Child) : this(child.id) {
+        parentId = child.parentId
+        isDir = child.isDir
+        title = child.title
+        album = child.album
+        artist = child.artist
+        track = child.track
+        year = child.year
+        genre = child.genre
+        coverArtId = child.coverArtId
+        size = child.size
+        contentType = child.contentType
+        suffix = child.suffix
+        transcodedContentType = child.transcodedContentType
+        transcodedSuffix = child.transcodedSuffix
+        duration = child.duration
+        bitrate = child.bitrate
+        samplingRate = child.samplingRate
+        bitDepth = child.bitDepth
+        path = child.path
+        isVideo = child.isVideo
+        userRating = child.userRating
+        averageRating = child.averageRating
+        playCount = child.playCount
+        discNumber = child.discNumber
+        created = child.created
+        starred = child.starred
+        albumId = child.albumId
+        artistId = child.artistId
+        type = child.type
+        bookmarkPosition = child.bookmarkPosition
+        originalWidth = child.originalWidth
+        originalHeight = child.originalHeight
+    }
+}
+
+@Keep
+data class DownloadStack(
+    var id: String,
+    var view: String?,
+)

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

@@ -0,0 +1,32 @@
+package com.cappielloantonio.tempo.model
+
+import android.os.Parcelable
+import androidx.annotation.Keep
+import androidx.annotation.Nullable
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import kotlinx.parcelize.Parcelize
+
+@Keep
+@Parcelize
+@Entity(tableName = "favorite")
+data class Favorite(
+    @PrimaryKey
+    @ColumnInfo(name = "timestamp")
+    var timestamp: Long,
+
+    @ColumnInfo(name = "songId")
+    val songId: String?,
+
+    @ColumnInfo(name = "albumId")
+    val albumId: String?,
+
+    @ColumnInfo(name = "artistId")
+    val artistId: String?,
+
+    @ColumnInfo(name = "toStar")
+    val toStar: Boolean,
+) : Parcelable {
+    override fun toString(): String = (songId ?: "null") + (albumId ?: "null") + (artistId ?: "null")
+}

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

@@ -0,0 +1,11 @@
+package com.cappielloantonio.tempo.model
+
+import androidx.annotation.Keep
+
+@Keep
+data class HomeSector(
+        val id: String,
+        val sectorTitle: String,
+        var isVisible: Boolean,
+        val order: Int,
+)

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/Queue.kt

@@ -0,0 +1,59 @@
+package com.cappielloantonio.tempo.model
+
+import androidx.annotation.Keep
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.cappielloantonio.tempo.subsonic.models.Child
+import kotlinx.parcelize.Parcelize
+
+@Keep
+@Parcelize
+@Entity(tableName = "queue")
+class Queue(
+    override val id: String,
+    @PrimaryKey
+    @ColumnInfo(name = "track_order")
+    var trackOrder: Int = 0,
+    @ColumnInfo(name = "last_play")
+    var lastPlay: Long = 0,
+    @ColumnInfo(name = "playing_changed")
+    var playingChanged: Long = 0,
+    @ColumnInfo(name = "stream_id")
+    var streamId: String? = null,
+) : Child(id) {
+    constructor(child: Child) : this(child.id) {
+        parentId = child.parentId
+        isDir = child.isDir
+        title = child.title
+        album = child.album
+        artist = child.artist
+        track = child.track
+        year = child.year
+        genre = child.genre
+        coverArtId = child.coverArtId
+        size = child.size
+        contentType = child.contentType
+        suffix = child.suffix
+        transcodedContentType = child.transcodedContentType
+        transcodedSuffix = child.transcodedSuffix
+        duration = child.duration
+        bitrate = child.bitrate
+        samplingRate = child.samplingRate
+        bitDepth = child.bitDepth
+        path = child.path
+        isVideo = child.isVideo
+        userRating = child.userRating
+        averageRating = child.averageRating
+        playCount = child.playCount
+        discNumber = child.discNumber
+        created = child.created
+        starred = child.starred
+        albumId = child.albumId
+        artistId = child.artistId
+        type = child.type
+        bookmarkPosition = child.bookmarkPosition
+        originalWidth = child.originalWidth
+        originalHeight = child.originalHeight
+    }
+}

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

@@ -0,0 +1,17 @@
+package com.cappielloantonio.tempo.model
+
+import android.os.Parcelable
+import androidx.annotation.Keep
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import kotlinx.parcelize.Parcelize
+
+@Keep
+@Parcelize
+@Entity(tableName = "recent_search")
+data class RecentSearch(
+    @PrimaryKey
+    @ColumnInfo(name = "search")
+    var search: String
+) : Parcelable

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

@@ -0,0 +1,9 @@
+package com.cappielloantonio.tempo.model
+
+import androidx.annotation.Keep
+
+@Keep
+data class ReplayGain(
+    var trackGain: Float = 0f,
+    var albumGain: Float = 0f,
+)

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

@@ -0,0 +1,39 @@
+package com.cappielloantonio.tempo.model
+
+import android.os.Parcelable
+import androidx.annotation.Keep
+import androidx.annotation.Nullable
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import kotlinx.parcelize.Parcelize
+
+@Keep
+@Parcelize
+@Entity(tableName = "server")
+data class Server(
+    @PrimaryKey
+    @ColumnInfo(name = "id")
+    val serverId: String,
+
+    @ColumnInfo(name = "server_name")
+    val serverName: String,
+
+    @ColumnInfo(name = "username")
+    val username: String,
+
+    @ColumnInfo(name = "password")
+    val password: String,
+
+    @ColumnInfo(name = "address")
+    val address: String,
+
+    @ColumnInfo(name = "local_address")
+    val localAddress: String?,
+
+    @ColumnInfo(name = "timestamp")
+    val timestamp: Long,
+
+    @ColumnInfo(name = "low_security", defaultValue = "false")
+    val isLowSecurity: Boolean
+) : Parcelable

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

@@ -0,0 +1,289 @@
+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
+import androidx.media3.common.MimeTypes
+import androidx.media3.common.util.UnstableApi
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import com.cappielloantonio.tempo.glide.CustomGlideRequest
+import com.cappielloantonio.tempo.subsonic.models.Child
+import com.cappielloantonio.tempo.subsonic.models.InternetRadioStation
+import com.cappielloantonio.tempo.subsonic.models.PodcastEpisode
+import com.cappielloantonio.tempo.util.Constants
+import com.cappielloantonio.tempo.util.MusicUtil
+import com.cappielloantonio.tempo.util.Preferences.getImageSize
+import java.util.Date
+
+@UnstableApi
+@Keep
+@Entity(tableName = "session_media_item")
+class SessionMediaItem() {
+    @PrimaryKey(autoGenerate = true)
+    @ColumnInfo(name = "index")
+    var index: Int = 0
+
+    @ColumnInfo(name = "id")
+    var id: String? = null
+
+    @ColumnInfo(name = "parent_id")
+    var parentId: String? = null
+
+    @ColumnInfo(name = "is_dir")
+    var isDir: Boolean = false
+
+    @ColumnInfo
+    var title: String? = null
+
+    @ColumnInfo
+    var album: String? = null
+
+    @ColumnInfo
+    var artist: String? = null
+
+    @ColumnInfo
+    var track: Int? = null
+
+    @ColumnInfo
+    var year: Int? = null
+
+    @ColumnInfo
+    var genre: String? = null
+
+    @ColumnInfo(name = "cover_art_id")
+    var coverArtId: String? = null
+
+    @ColumnInfo
+    var size: Long? = null
+
+    @ColumnInfo(name = "content_type")
+    var contentType: String? = null
+
+    @ColumnInfo
+    var suffix: String? = null
+
+    @ColumnInfo("transcoding_content_type")
+    var transcodedContentType: String? = null
+
+    @ColumnInfo(name = "transcoded_suffix")
+    var transcodedSuffix: String? = null
+
+    @ColumnInfo
+    var duration: Int? = null
+
+    @ColumnInfo("bitrate")
+    var bitrate: Int? = null
+
+    @ColumnInfo
+    var path: String? = null
+
+    @ColumnInfo(name = "is_video")
+    var isVideo: Boolean = false
+
+    @ColumnInfo(name = "user_rating")
+    var userRating: Int? = null
+
+    @ColumnInfo(name = "average_rating")
+    var averageRating: Double? = null
+
+    @ColumnInfo(name = "play_count")
+    var playCount: Long? = null
+
+    @ColumnInfo(name = "disc_number")
+    var discNumber: Int? = null
+
+    @ColumnInfo
+    var created: Date? = null
+
+    @ColumnInfo
+    var starred: Date? = null
+
+    @ColumnInfo(name = "album_id")
+    var albumId: String? = null
+
+    @ColumnInfo(name = "artist_id")
+    var artistId: String? = null
+
+    @ColumnInfo
+    var type: String? = null
+
+    @ColumnInfo(name = "bookmark_position")
+    var bookmarkPosition: Long? = null
+
+    @ColumnInfo(name = "original_width")
+    var originalWidth: Int? = null
+
+    @ColumnInfo(name = "original_height")
+    var originalHeight: Int? = null
+
+    @ColumnInfo(name = "stream_id")
+    var streamId: String? = null
+
+    @ColumnInfo(name = "stream_url")
+    var streamUrl: String? = null
+
+    @ColumnInfo(name = "timestamp")
+    var timestamp: Long? = null
+
+    constructor(child: Child) : this() {
+        id = child.id
+        parentId = child.parentId
+        isDir = child.isDir
+        title = child.title
+        album = child.album
+        artist = child.artist
+        track = child.track
+        year = child.year
+        genre = child.genre
+        coverArtId = child.coverArtId
+        size = child.size
+        contentType = child.contentType
+        suffix = child.suffix
+        transcodedContentType = child.transcodedContentType
+        transcodedSuffix = child.transcodedSuffix
+        duration = child.duration
+        bitrate = child.bitrate
+        path = child.path
+        isVideo = child.isVideo
+        userRating = child.userRating
+        averageRating = child.averageRating
+        playCount = child.playCount
+        discNumber = child.discNumber
+        created = child.created
+        starred = child.starred
+        albumId = child.albumId
+        artistId = child.artistId
+        type = Constants.MEDIA_TYPE_MUSIC
+        bookmarkPosition = child.bookmarkPosition
+        originalWidth = child.originalWidth
+        originalHeight = child.originalHeight
+    }
+
+    constructor(podcastEpisode: PodcastEpisode) : this() {
+        id = podcastEpisode.id
+        parentId = podcastEpisode.parentId
+        isDir = podcastEpisode.isDir
+        title = podcastEpisode.title
+        album = podcastEpisode.album
+        artist = podcastEpisode.artist
+        year = podcastEpisode.year
+        genre = podcastEpisode.genre
+        coverArtId = podcastEpisode.coverArtId
+        size = podcastEpisode.size
+        contentType = podcastEpisode.contentType
+        suffix = podcastEpisode.suffix
+        duration = podcastEpisode.duration
+        bitrate = podcastEpisode.bitrate
+        path = podcastEpisode.path
+        isVideo = podcastEpisode.isVideo
+        created = podcastEpisode.created
+        artistId = podcastEpisode.artistId
+        streamId = podcastEpisode.streamId
+        type = Constants.MEDIA_TYPE_PODCAST
+    }
+
+    constructor(internetRadioStation: InternetRadioStation) : this() {
+        id = internetRadioStation.id
+        title = internetRadioStation.name
+        streamUrl = internetRadioStation.streamUrl
+        type = Constants.MEDIA_TYPE_RADIO
+    }
+
+    fun getMediaItem(): MediaItem {
+        val uri: Uri = getStreamUri()
+        val artworkUri = Uri.parse(CustomGlideRequest.createUrl(coverArtId, getImageSize()))
+
+        val bundle = Bundle()
+        bundle.putString("id", id)
+        bundle.putString("parentId", parentId)
+        bundle.putBoolean("isDir", isDir)
+        bundle.putString("title", title)
+        bundle.putString("album", album)
+        bundle.putString("artist", artist)
+        bundle.putInt("track", track ?: 0)
+        bundle.putInt("year", year ?: 0)
+        bundle.putString("genre", genre)
+        bundle.putString("coverArtId", coverArtId)
+        bundle.putLong("size", size ?: 0)
+        bundle.putString("contentType", contentType)
+        bundle.putString("suffix", suffix)
+        bundle.putString("transcodedContentType", transcodedContentType)
+        bundle.putString("transcodedSuffix", transcodedSuffix)
+        bundle.putInt("duration", duration ?: 0)
+        bundle.putInt("bitrate", bitrate ?: 0)
+        bundle.putString("path", path)
+        bundle.putBoolean("isVideo", isVideo)
+        bundle.putInt("userRating", userRating ?: 0)
+        bundle.putDouble("averageRating", averageRating ?: .0)
+        bundle.putLong("playCount", playCount ?: 0)
+        bundle.putInt("discNumber", discNumber ?: 0)
+        bundle.putLong("created", created?.time ?: 0)
+        bundle.putLong("starred", starred?.time ?: 0)
+        bundle.putString("albumId", albumId)
+        bundle.putString("artistId", artistId)
+        bundle.putString("type", Constants.MEDIA_TYPE_MUSIC)
+        bundle.putLong("bookmarkPosition", bookmarkPosition ?: 0)
+        bundle.putInt("originalWidth", originalWidth ?: 0)
+        bundle.putInt("originalHeight", originalHeight ?: 0)
+        bundle.putString("uri", uri.toString())
+
+        return MediaItem.Builder()
+            .setMediaId(id!!)
+            .setMediaMetadata(
+                MediaMetadata.Builder()
+                    .setTitle(title)
+                    .setTrackNumber(track ?: 0)
+                    .setDiscNumber(discNumber ?: 0)
+                    .setReleaseYear(year ?: 0)
+                    .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)
+                    .build()
+            )
+            .setRequestMetadata(
+                RequestMetadata.Builder()
+                    .setMediaUri(uri)
+                    .setExtras(bundle)
+                    .build()
+            )
+            .setMimeType(MimeTypes.BASE_TYPE_AUDIO)
+            .setUri(uri)
+            .build()
+    }
+
+    private fun getStreamUri(): Uri {
+        return when (type) {
+            Constants.MEDIA_TYPE_MUSIC -> {
+                MusicUtil.getStreamUri(id)
+            }
+
+            Constants.MEDIA_TYPE_PODCAST -> {
+                MusicUtil.getStreamUri(streamId)
+            }
+
+            Constants.MEDIA_TYPE_RADIO -> {
+                Uri.parse(streamUrl)
+            }
+
+            else -> {
+                MusicUtil.getStreamUri(id)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,301 @@
+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.interfaces.DecadesCallback;
+import com.cappielloantonio.tempo.interfaces.MediaCallback;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+import com.cappielloantonio.tempo.subsonic.models.AlbumID3;
+import com.cappielloantonio.tempo.subsonic.models.AlbumInfo;
+import com.cappielloantonio.tempo.subsonic.models.Child;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+public class AlbumRepository {
+    public MutableLiveData<List<AlbumID3>> getAlbums(String type, int size, Integer fromYear, Integer toYear) {
+        MutableLiveData<List<AlbumID3>> listLiveAlbums = new MutableLiveData<>(new ArrayList<>());
+
+        App.getSubsonicClientInstance(false)
+                .getAlbumSongListClient()
+                .getAlbumList2(type, size, 0, fromYear, toYear)
+                .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().getAlbumList2() != null 
+                            && response.body().getSubsonicResponse().getAlbumList2().getAlbums() != null) {
+                            
+                            listLiveAlbums.setValue(response.body().getSubsonicResponse().getAlbumList2().getAlbums());
+                        } else {
+                            Log.e("AlbumRepository", "API Error on getAlbums. HTTP Code: " + response.code());
+                            listLiveAlbums.setValue(new ArrayList<>());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        Log.e("AlbumRepository", "Network Failure on getAlbums: " + t.getMessage());
+                        listLiveAlbums.setValue(new ArrayList<>());
+                    }
+                });
+
+        return listLiveAlbums;
+    }
+
+    public MutableLiveData<List<AlbumID3>> getStarredAlbums(boolean random, int size) {
+        MutableLiveData<List<AlbumID3>> starredAlbums = new MutableLiveData<>(new ArrayList<>());
+
+        App.getSubsonicClientInstance(false)
+                .getAlbumSongListClient()
+                .getStarred2()
+                .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().getStarred2() != null) {
+                            List<AlbumID3> albums = response.body().getSubsonicResponse().getStarred2().getAlbums();
+
+                            if (albums != null) {
+                                if (random) {
+                                    Collections.shuffle(albums);
+                                    starredAlbums.setValue(albums.subList(0, Math.min(size, albums.size())));
+                                } else {
+                                    starredAlbums.setValue(albums);
+                                }
+                            }
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return starredAlbums;
+    }
+
+    public void setRating(String id, int rating) {
+        App.getSubsonicClientInstance(false)
+                .getMediaAnnotationClient()
+                .setRating(id, rating)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public MutableLiveData<List<Child>> getAlbumTracks(String id) {
+        MutableLiveData<List<Child>> albumTracks = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getAlbum(id)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        List<Child> tracks = new ArrayList<>();
+
+                        if (response.isSuccessful() && response.body() != null && response.body().getSubsonicResponse().getAlbum() != null) {
+                            if (response.body().getSubsonicResponse().getAlbum().getSongs() != null) {
+                                tracks.addAll(response.body().getSubsonicResponse().getAlbum().getSongs());
+                            }
+                        }
+
+                        albumTracks.setValue(tracks);
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return albumTracks;
+    }
+
+    public MutableLiveData<List<AlbumID3>> getArtistAlbums(String id) {
+        MutableLiveData<List<AlbumID3>> artistsAlbum = new MutableLiveData<>(new ArrayList<>());
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getArtist(id)
+                .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();
+                            albums.sort(Comparator.comparing(AlbumID3::getYear));
+                            Collections.reverse(albums);
+                            artistsAlbum.setValue(albums);
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return artistsAlbum;
+    }
+
+    public MutableLiveData<AlbumID3> getAlbum(String id) {
+        MutableLiveData<AlbumID3> album = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getAlbum(id)
+                .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().getAlbum() != null) {
+                            album.setValue(response.body().getSubsonicResponse().getAlbum());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return album;
+    }
+
+    public MutableLiveData<AlbumInfo> getAlbumInfo(String id) {
+        MutableLiveData<AlbumInfo> albumInfo = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getAlbumInfo2(id)
+                .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().getAlbumInfo() != null) {
+                            albumInfo.setValue(response.body().getSubsonicResponse().getAlbumInfo());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return albumInfo;
+    }
+
+    public void getInstantMix(AlbumID3 album, int count, MediaCallback callback) {
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getSimilarSongs2(album.getId(), count)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        List<Child> songs = new ArrayList<>();
+
+                        if (response.isSuccessful() && response.body() != null && response.body().getSubsonicResponse().getSimilarSongs2() != null) {
+                            songs.addAll(response.body().getSubsonicResponse().getSimilarSongs2().getSongs());
+                        }
+
+                        callback.onLoadMedia(songs);
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        callback.onLoadMedia(new ArrayList<>());
+                    }
+                });
+    }
+
+    public MutableLiveData<List<Integer>> getDecades() {
+        MutableLiveData<List<Integer>> decades = new MutableLiveData<>();
+
+        getFirstAlbum(new DecadesCallback() {
+            @Override
+            public void onLoadYear(int first) {
+                getLastAlbum(new DecadesCallback() {
+                    @Override
+                    public void onLoadYear(int last) {
+                        if (first != -1 && last != -1) {
+                            List<Integer> decadeList = new ArrayList();
+
+                            int startDecade = first - (first % 10);
+                            int lastDecade = last - (last % 10);
+
+                            while (startDecade <= lastDecade) {
+                                decadeList.add(startDecade);
+                                startDecade = startDecade + 10;
+                            }
+
+                            decades.setValue(decadeList);
+                        }
+                    }
+                });
+            }
+        });
+
+        return decades;
+    }
+
+    private void getFirstAlbum(DecadesCallback callback) {
+        App.getSubsonicClientInstance(false)
+                .getAlbumSongListClient()
+                .getAlbumList2("byYear", 1, 0, 1900, Calendar.getInstance().get(Calendar.YEAR))
+                .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().getAlbumList2() != null && response.body().getSubsonicResponse().getAlbumList2().getAlbums() != null && !response.body().getSubsonicResponse().getAlbumList2().getAlbums().isEmpty()) {
+                            callback.onLoadYear(response.body().getSubsonicResponse().getAlbumList2().getAlbums().get(0).getYear());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        callback.onLoadYear(-1);
+                    }
+                });
+    }
+
+    private void getLastAlbum(DecadesCallback callback) {
+        App.getSubsonicClientInstance(false)
+                .getAlbumSongListClient()
+                .getAlbumList2("byYear", 1, 0, Calendar.getInstance().get(Calendar.YEAR), 1900)
+                .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().getAlbumList2() != null && response.body().getSubsonicResponse().getAlbumList2().getAlbums() != null) {
+                            if (!response.body().getSubsonicResponse().getAlbumList2().getAlbums().isEmpty() && !response.body().getSubsonicResponse().getAlbumList2().getAlbums().isEmpty()) {
+                                callback.onLoadYear(response.body().getSubsonicResponse().getAlbumList2().getAlbums().get(0).getYear());
+                            } else {
+                                callback.onLoadYear(-1);
+                            }
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        callback.onLoadYear(-1);
+                    }
+                });
+    }
+}

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

@@ -0,0 +1,387 @@
+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;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+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<>());
+
+        App.getSubsonicClientInstance(false)
+                .getAlbumSongListClient()
+                .getStarred2()
+                .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().getStarred2() != null) {
+                            List<ArtistID3> artists = response.body().getSubsonicResponse().getStarred2().getArtists();
+
+                            if (artists != null) {
+                                if (!random) {
+                                    getArtistInfo(artists, starredArtists);
+                                } else {
+                                    Collections.shuffle(artists);
+                                    getArtistInfo(artists.subList(0, Math.min(size, artists.size())), starredArtists);
+                                }
+                            }
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return starredArtists;
+    }
+
+    public MutableLiveData<List<ArtistID3>> getArtists(boolean random, int size) {
+        MutableLiveData<List<ArtistID3>> listLiveArtists = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getArtists()
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        if (response.isSuccessful() && response.body() != null) {
+                            List<ArtistID3> artists = new ArrayList<>();
+
+                            if(response.body().getSubsonicResponse().getArtists() != null && response.body().getSubsonicResponse().getArtists().getIndices() != null) {
+                                for (IndexID3 index : response.body().getSubsonicResponse().getArtists().getIndices()) {
+                                    if(index != null && index.getArtists() != null) {
+                                        artists.addAll(index.getArtists());
+                                    }
+                                }
+                            }
+
+                            if (random) {
+                                Collections.shuffle(artists);
+                                getArtistInfo(artists.subList(0, artists.size() / size > 0 ? size : artists.size()), listLiveArtists);
+                            } else {
+                                listLiveArtists.setValue(artists);
+                            }
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                    }
+                });
+
+        return listLiveArtists;
+    }
+
+    /*
+     * 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();
+        if (liveArtists == null) liveArtists = new ArrayList<>();
+        list.setValue(liveArtists);
+
+        for (ArtistID3 artist : artists) {
+            App.getSubsonicClientInstance(false)
+                    .getBrowsingClient()
+                    .getArtist(artist.getId())
+                    .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) {
+                                addToMutableLiveData(list, response.body().getSubsonicResponse().getArtist());
+                            }
+                        }
+
+                        @Override
+                        public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                        }
+                    });
+        }
+    }
+
+    public MutableLiveData<ArtistID3> getArtistInfo(String id) {
+        MutableLiveData<ArtistID3> artist = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getArtist(id)
+                .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) {
+                            artist.setValue(response.body().getSubsonicResponse().getArtist());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return artist;
+    }
+
+    public MutableLiveData<ArtistInfo2> getArtistFullInfo(String id) {
+        MutableLiveData<ArtistInfo2> artistFullInfo = new MutableLiveData<>(null);
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getArtistInfo2(id)
+                .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().getArtistInfo2() != null) {
+                            artistFullInfo.setValue(response.body().getSubsonicResponse().getArtistInfo2());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return artistFullInfo;
+    }
+
+    public void setRating(String id, int rating) {
+        App.getSubsonicClientInstance(false)
+                .getMediaAnnotationClient()
+                .setRating(id, rating)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public MutableLiveData<ArtistID3> getArtist(String id) {
+        MutableLiveData<ArtistID3> artist = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getArtist(id)
+                .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) {
+                            artist.setValue(response.body().getSubsonicResponse().getArtist());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return artist;
+    }
+
+    public MutableLiveData<List<Child>> getInstantMix(ArtistID3 artist, int count) {
+        MutableLiveData<List<Child>> instantMix = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getSimilarSongs2(artist.getId(), count)
+                .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().getSimilarSongs2() != null) {
+                            instantMix.setValue(response.body().getSubsonicResponse().getSimilarSongs2().getSongs());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return instantMix;
+    }
+
+    public MutableLiveData<List<Child>> getRandomSong(ArtistID3 artist, int count) {
+        MutableLiveData<List<Child>> randomSongs = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getArtist(artist.getId())
+                .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("ArtistRepository", "Got albums directly: " + albums.size());
+                            if (albums.isEmpty()) {
+                                Log.d("ArtistRepository", "No albums found in artist response");
+                                return;
+                            }
+
+                            Collections.shuffle(albums);
+                            int[] counts = albums.stream().mapToInt(AlbumID3::getSongCount).toArray();
+                            Arrays.parallelPrefix(counts, Integer::sum);
+                            int albumLimit = 0;
+                            int multiplier = 4; // get more than the limit so we can shuffle them
+                            while (albumLimit < albums.size() && counts[albumLimit] < count * multiplier)
+                                albumLimit++;
+                            Log.d("ArtistRepository", String.format("Retaining %d/%d albums", albumLimit, albums.size()));
+
+                            fetchAllAlbumSongsWithCallback(albums.stream().limit(albumLimit).collect(Collectors.toList()), songs -> {
+                                Collections.shuffle(songs);
+                                randomSongs.setValue(songs.stream().limit(count).collect(Collectors.toList()));
+                            });
+                        } else {
+                            Log.d("ArtistRepository", "Failed to get artist info");
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        Log.d("ArtistRepository", "Error getting artist info: " + t.getMessage());
+                    }
+                });
+
+        return randomSongs;
+    }
+
+    public MutableLiveData<List<Child>> getTopSongs(String artistName, int count) {
+        MutableLiveData<List<Child>> topSongs = new MutableLiveData<>(new ArrayList<>());
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getTopSongs(artistName, count)
+                .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().getTopSongs() != null && response.body().getSubsonicResponse().getTopSongs().getSongs() != null) {
+                            topSongs.setValue(response.body().getSubsonicResponse().getTopSongs().getSongs());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return topSongs;
+    }
+
+    private void addToMutableLiveData(MutableLiveData<List<ArtistID3>> liveData, ArtistID3 artist) {
+        List<ArtistID3> liveArtists = liveData.getValue();
+        if (liveArtists != null) liveArtists.add(artist);
+        liveData.setValue(liveArtists);
+    }
+}

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

@@ -0,0 +1,39 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.lifecycle.LiveData;
+
+import com.cappielloantonio.tempo.database.AppDatabase;
+import com.cappielloantonio.tempo.database.dao.ChronologyDao;
+import com.cappielloantonio.tempo.model.Chronology;
+
+import java.util.Calendar;
+import java.util.List;
+
+public class ChronologyRepository {
+    private final ChronologyDao chronologyDao = AppDatabase.getInstance().chronologyDao();
+
+    public LiveData<List<Chronology>> getChronology(String server, long start, long end) {
+        return chronologyDao.getAllFrom(start, end, server);
+    }
+
+    public void insert(Chronology item) {
+        InsertThreadSafe insert = new InsertThreadSafe(chronologyDao, item);
+        Thread thread = new Thread(insert);
+        thread.start();
+    }
+
+    private static class InsertThreadSafe implements Runnable {
+        private final ChronologyDao chronologyDao;
+        private final Chronology item;
+
+        public InsertThreadSafe(ChronologyDao chronologyDao, Chronology item) {
+            this.chronologyDao = chronologyDao;
+            this.item = item;
+        }
+
+        @Override
+        public void run() {
+            chronologyDao.insert(item);
+        }
+    }
+}

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

@@ -0,0 +1,89 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.MutableLiveData;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+import com.cappielloantonio.tempo.subsonic.models.Directory;
+import com.cappielloantonio.tempo.subsonic.models.Indexes;
+import com.cappielloantonio.tempo.subsonic.models.MusicFolder;
+
+import java.util.List;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+public class DirectoryRepository {
+    private static final String TAG = "DirectoryRepository";
+
+    public MutableLiveData<List<MusicFolder>> getMusicFolders() {
+        MutableLiveData<List<MusicFolder>> liveMusicFolders = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getMusicFolders()
+                .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().getMusicFolders() != null) {
+                            liveMusicFolders.setValue(response.body().getSubsonicResponse().getMusicFolders().getMusicFolders());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return liveMusicFolders;
+    }
+
+    public MutableLiveData<Indexes> getIndexes(String musicFolderId, Long ifModifiedSince) {
+        MutableLiveData<Indexes> liveIndexes = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getIndexes(musicFolderId, ifModifiedSince)
+                .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().getIndexes() != null) {
+                            liveIndexes.setValue(response.body().getSubsonicResponse().getIndexes());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return liveIndexes;
+    }
+
+    public MutableLiveData<Directory> getMusicDirectory(String id) {
+        MutableLiveData<Directory> liveMusicDirectory = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getMusicDirectory(id)
+                .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().getDirectory() != null) {
+                            liveMusicDirectory.setValue(response.body().getSubsonicResponse().getDirectory());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        t.printStackTrace();
+                    }
+                });
+
+        return liveMusicDirectory;
+    }
+}

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

@@ -0,0 +1,213 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.lifecycle.LiveData;
+
+import com.cappielloantonio.tempo.database.AppDatabase;
+import com.cappielloantonio.tempo.database.dao.DownloadDao;
+import com.cappielloantonio.tempo.database.dao.FavoriteDao;
+import com.cappielloantonio.tempo.model.Download;
+import com.cappielloantonio.tempo.model.Favorite;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DownloadRepository {
+    private final DownloadDao downloadDao = AppDatabase.getInstance().downloadDao();
+
+    public LiveData<List<Download>> getLiveDownload() {
+        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;
+
+        GetDownloadThreadSafe getDownloadThreadSafe = new GetDownloadThreadSafe(downloadDao, id);
+        Thread thread = new Thread(getDownloadThreadSafe);
+        thread.start();
+
+        try {
+            thread.join();
+            download = getDownloadThreadSafe.getDownload();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        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;
+        private Download download;
+
+        public GetDownloadThreadSafe(DownloadDao downloadDao, String id) {
+            this.downloadDao = downloadDao;
+            this.id = id;
+        }
+
+        @Override
+        public void run() {
+            download = downloadDao.getOne(id);
+        }
+
+        public Download getDownload() {
+            return download;
+        }
+    }
+
+    public void insert(Download download) {
+        InsertThreadSafe insert = new InsertThreadSafe(downloadDao, download);
+        Thread thread = new Thread(insert);
+        thread.start();
+    }
+
+    private static class InsertThreadSafe implements Runnable {
+        private final DownloadDao downloadDao;
+        private final Download download;
+
+        public InsertThreadSafe(DownloadDao downloadDao, Download download) {
+            this.downloadDao = downloadDao;
+            this.download = download;
+        }
+
+        @Override
+        public void run() {
+            downloadDao.insert(download);
+        }
+    }
+
+    public void update(String id) {
+        UpdateThreadSafe update = new UpdateThreadSafe(downloadDao, id);
+        Thread thread = new Thread(update);
+        thread.start();
+    }
+
+    private static class UpdateThreadSafe implements Runnable {
+        private final DownloadDao downloadDao;
+        private final String id;
+
+        public UpdateThreadSafe(DownloadDao downloadDao, String id) {
+            this.downloadDao = downloadDao;
+            this.id = id;
+        }
+
+        @Override
+        public void run() {
+            downloadDao.update(id);
+        }
+    }
+
+    public void insertAll(List<Download> downloads) {
+        InsertAllThreadSafe insertAll = new InsertAllThreadSafe(downloadDao, downloads);
+        Thread thread = new Thread(insertAll);
+        thread.start();
+    }
+
+    private static class InsertAllThreadSafe implements Runnable {
+        private final DownloadDao downloadDao;
+        private final List<Download> downloads;
+
+        public InsertAllThreadSafe(DownloadDao downloadDao, List<Download> downloads) {
+            this.downloadDao = downloadDao;
+            this.downloads = downloads;
+        }
+
+        @Override
+        public void run() {
+            downloadDao.insertAll(downloads);
+        }
+    }
+
+    public void deleteAll() {
+        DeleteAllThreadSafe deleteAll = new DeleteAllThreadSafe(downloadDao);
+        Thread thread = new Thread(deleteAll);
+        thread.start();
+    }
+
+    private static class DeleteAllThreadSafe implements Runnable {
+        private final DownloadDao downloadDao;
+
+        public DeleteAllThreadSafe(DownloadDao downloadDao) {
+            this.downloadDao = downloadDao;
+        }
+
+        @Override
+        public void run() {
+            downloadDao.deleteAll();
+        }
+    }
+
+    public void delete(String id) {
+        DeleteThreadSafe delete = new DeleteThreadSafe(downloadDao, id);
+        Thread thread = new Thread(delete);
+        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;
+
+        public DeleteThreadSafe(DownloadDao downloadDao, String id) {
+            this.downloadDao = downloadDao;
+            this.id = id;
+        }
+
+        @Override
+        public void run() {
+            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/FavoriteRepository.java

@@ -0,0 +1,140 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.annotation.NonNull;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.database.AppDatabase;
+import com.cappielloantonio.tempo.database.dao.FavoriteDao;
+import com.cappielloantonio.tempo.interfaces.StarCallback;
+import com.cappielloantonio.tempo.model.Favorite;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+public class FavoriteRepository {
+    private final FavoriteDao favoriteDao = AppDatabase.getInstance().favoriteDao();
+
+    public void star(String id, String albumId, String artistId, StarCallback starCallback) {
+        App.getSubsonicClientInstance(false)
+                .getMediaAnnotationClient()
+                .star(id, albumId, artistId)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        if (response.isSuccessful()) {
+                            starCallback.onSuccess();
+                        } else {
+                            starCallback.onError();
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        starCallback.onError();
+                    }
+                });
+    }
+
+    public void unstar(String id, String albumId, String artistId, StarCallback starCallback) {
+        App.getSubsonicClientInstance(false)
+                .getMediaAnnotationClient()
+                .unstar(id, albumId, artistId)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        if (response.isSuccessful()) {
+                            starCallback.onSuccess();
+                        } else {
+                            starCallback.onError();
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        starCallback.onError();
+                    }
+                });
+    }
+
+    public List<Favorite> getFavorites() {
+        List<Favorite> favorites = new ArrayList<>();
+
+        GetAllThreadSafe getAllThreadSafe = new GetAllThreadSafe(favoriteDao);
+        Thread thread = new Thread(getAllThreadSafe);
+        thread.start();
+
+        try {
+            thread.join();
+            favorites = getAllThreadSafe.getFavorites();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        return favorites;
+    }
+
+    private static class GetAllThreadSafe implements Runnable {
+        private final FavoriteDao favoriteDao;
+        private List<Favorite> favorites = new ArrayList<>();
+
+        public GetAllThreadSafe(FavoriteDao favoriteDao) {
+            this.favoriteDao = favoriteDao;
+        }
+
+        @Override
+        public void run() {
+            favorites = favoriteDao.getAll();
+        }
+
+        public List<Favorite> getFavorites() {
+            return favorites;
+        }
+    }
+
+    public void starLater(String id, String albumId, String artistId, boolean toStar) {
+        InsertThreadSafe insert = new InsertThreadSafe(favoriteDao, new Favorite(System.currentTimeMillis(), id, albumId, artistId, toStar));
+        Thread thread = new Thread(insert);
+        thread.start();
+    }
+
+    private static class InsertThreadSafe implements Runnable {
+        private final FavoriteDao favoriteDao;
+        private final Favorite favorite;
+
+        public InsertThreadSafe(FavoriteDao favoriteDao, Favorite favorite) {
+            this.favoriteDao = favoriteDao;
+            this.favorite = favorite;
+        }
+
+        @Override
+        public void run() {
+            favoriteDao.insert(favorite);
+        }
+    }
+
+    public void delete(Favorite favorite) {
+        DeleteThreadSafe delete = new DeleteThreadSafe(favoriteDao, favorite);
+        Thread thread = new Thread(delete);
+        thread.start();
+    }
+
+    private static class DeleteThreadSafe implements Runnable {
+        private final FavoriteDao favoriteDao;
+        private final Favorite favorite;
+
+        public DeleteThreadSafe(FavoriteDao favoriteDao, Favorite favorite) {
+            this.favoriteDao = favoriteDao;
+            this.favorite = favorite;
+        }
+
+        @Override
+        public void run() {
+            favoriteDao.delete(favorite);
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.MutableLiveData;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+import com.cappielloantonio.tempo.subsonic.models.Genre;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+public class GenreRepository {
+    public MutableLiveData<List<Genre>> getGenres(boolean random, int size) {
+        MutableLiveData<List<Genre>> genres = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getGenres()
+                .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() != null && response.body().getSubsonicResponse().getGenres() != null) {
+                            List<Genre> genreList = response.body().getSubsonicResponse().getGenres().getGenres();
+
+                            if (genreList == null || genreList.isEmpty()) {
+                                genres.setValue(Collections.emptyList());
+                                return;
+                            }
+
+                            if (random) {
+                                Collections.shuffle(genreList);
+                            }
+
+                            if (size != -1) {
+                                genres.setValue(genreList.subList(0, Math.min(size, genreList.size())));
+                            } else {
+                                genres.setValue(genreList.stream().sorted(Comparator.comparing(Genre::getGenre)).collect(Collectors.toList()));
+                            }
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return genres;
+    }
+}

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/repository/OpenRepository.java

@@ -0,0 +1,37 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.MutableLiveData;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+import com.cappielloantonio.tempo.subsonic.models.LyricsList;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+public class OpenRepository {
+    public MutableLiveData<LyricsList> getLyricsBySongId(String id) {
+        MutableLiveData<LyricsList> lyricsList = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getOpenClient()
+                .getLyricsBySongId(id)
+                .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().getLyricsList() != null) {
+                            lyricsList.setValue(response.body().getSubsonicResponse().getLyricsList());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return lyricsList;
+    }
+}

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

@@ -0,0 +1,229 @@
+package com.cappielloantonio.tempo.repository;
+
+import static android.provider.Settings.System.getString;
+
+import android.provider.Settings;
+import android.widget.Toast;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.R;
+import com.cappielloantonio.tempo.database.AppDatabase;
+import com.cappielloantonio.tempo.database.dao.PlaylistDao;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+import com.cappielloantonio.tempo.subsonic.models.Child;
+import com.cappielloantonio.tempo.subsonic.models.Playlist;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+public class PlaylistRepository {
+    @androidx.media3.common.util.UnstableApi
+    private final PlaylistDao playlistDao = AppDatabase.getInstance().playlistDao();
+    public MutableLiveData<List<Playlist>> getPlaylists(boolean random, int size) {
+        MutableLiveData<List<Playlist>> listLivePlaylists = new MutableLiveData<>(new ArrayList<>());
+
+        App.getSubsonicClientInstance(false)
+                .getPlaylistClient()
+                .getPlaylists()
+                .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().getPlaylists() != null && response.body().getSubsonicResponse().getPlaylists().getPlaylists() != null) {
+                            List<Playlist> playlists = response.body().getSubsonicResponse().getPlaylists().getPlaylists();
+
+                            if (random) {
+                                Collections.shuffle(playlists);
+                                listLivePlaylists.setValue(playlists.subList(0, Math.min(playlists.size(), size)));
+                            } else {
+                                listLivePlaylists.setValue(playlists);
+                            }
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                    }
+                });
+
+        return listLivePlaylists;
+    }
+
+    public MutableLiveData<List<Child>> getPlaylistSongs(String id) {
+        MutableLiveData<List<Child>> listLivePlaylistSongs = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getPlaylistClient()
+                .getPlaylist(id)
+                .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().getPlaylist() != null) {
+                            List<Child> songs = response.body().getSubsonicResponse().getPlaylist().getEntries();
+                            listLivePlaylistSongs.setValue(songs);
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                    }
+                });
+
+        return listLivePlaylistSongs;
+    }
+
+    public MutableLiveData<Playlist> getPlaylist(String id) {
+        MutableLiveData<Playlist> playlistLiveData = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getPlaylistClient()
+                .getPlaylist(id)
+                .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().getPlaylist() != null) {
+                            playlistLiveData.setValue(response.body().getSubsonicResponse().getPlaylist());
+                        } else {
+                            playlistLiveData.setValue(null);
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        playlistLiveData.setValue(null);
+                    }
+                });
+
+        return playlistLiveData;
+    }
+
+    public void addSongToPlaylist(String playlistId, ArrayList<String> songsId) {
+        if (songsId.isEmpty()) {
+            Toast.makeText(App.getContext(), App.getContext().getString(R.string.playlist_chooser_dialog_toast_all_skipped), Toast.LENGTH_SHORT).show();
+        } else{
+            App.getSubsonicClientInstance(false)
+                    .getPlaylistClient()
+                    .updatePlaylist(playlistId, null, true, songsId, null)
+                    .enqueue(new Callback<ApiResponse>() {
+                        @Override
+                        public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                            Toast.makeText(App.getContext(), App.getContext().getString(R.string.playlist_chooser_dialog_toast_add_success), Toast.LENGTH_SHORT).show();
+                        }
+
+                        @Override
+                        public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                            Toast.makeText(App.getContext(), App.getContext().getString(R.string.playlist_chooser_dialog_toast_add_failure), Toast.LENGTH_SHORT).show();
+                        }
+                    });
+        }
+    }
+
+    public void createPlaylist(String playlistId, String name, ArrayList<String> songsId) {
+        App.getSubsonicClientInstance(false)
+                .getPlaylistClient()
+                .createPlaylist(playlistId, name, songsId)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public void updatePlaylist(String playlistId, String name, ArrayList<String> songsId) {
+        App.getSubsonicClientInstance(false)
+                .getPlaylistClient()
+                .deletePlaylist(playlistId)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        createPlaylist(null, name, songsId);
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public void deletePlaylist(String playlistId) {
+        App.getSubsonicClientInstance(false)
+                .getPlaylistClient()
+                .deletePlaylist(playlistId)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+    @androidx.media3.common.util.UnstableApi
+    public LiveData<List<Playlist>> getPinnedPlaylists() {
+        return playlistDao.getAll();
+    }
+
+    @androidx.media3.common.util.UnstableApi
+    public void insert(Playlist playlist) {
+        InsertThreadSafe insert = new InsertThreadSafe(playlistDao, playlist);
+        Thread thread = new Thread(insert);
+        thread.start();
+    }
+
+    @androidx.media3.common.util.UnstableApi
+    public void delete(Playlist playlist) {
+        DeleteThreadSafe delete = new DeleteThreadSafe(playlistDao, playlist);
+        Thread thread = new Thread(delete);
+        thread.start();
+    }
+
+    private static class InsertThreadSafe implements Runnable {
+        private final PlaylistDao playlistDao;
+        private final Playlist playlist;
+
+        public InsertThreadSafe(PlaylistDao playlistDao, Playlist playlist) {
+            this.playlistDao = playlistDao;
+            this.playlist = playlist;
+        }
+
+        @Override
+        public void run() {
+            playlistDao.insert(playlist);
+        }
+    }
+
+    private static class DeleteThreadSafe implements Runnable {
+        private final PlaylistDao playlistDao;
+        private final Playlist playlist;
+
+        public DeleteThreadSafe(PlaylistDao playlistDao, Playlist playlist) {
+            this.playlistDao = playlistDao;
+            this.playlist = playlist;
+        }
+
+        @Override
+        public void run() {
+            playlistDao.delete(playlist);
+        }
+    }
+}

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

@@ -0,0 +1,153 @@
+package com.cappielloantonio.tempo.repository;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.MutableLiveData;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+import com.cappielloantonio.tempo.subsonic.models.PodcastChannel;
+import com.cappielloantonio.tempo.subsonic.models.PodcastEpisode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+public class PodcastRepository {
+    private static final String TAG = "PodcastRepository";
+
+    public MutableLiveData<List<PodcastChannel>> getPodcastChannels(boolean includeEpisodes, String channelId) {
+        MutableLiveData<List<PodcastChannel>> livePodcastChannel = new MutableLiveData<>(new ArrayList<>());
+
+        App.getSubsonicClientInstance(false)
+                .getPodcastClient()
+                .getPodcasts(includeEpisodes, channelId)
+                .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().getPodcasts() != null) {
+                            livePodcastChannel.setValue(response.body().getSubsonicResponse().getPodcasts().getChannels());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return livePodcastChannel;
+    }
+
+    public MutableLiveData<List<PodcastEpisode>> getNewestPodcastEpisodes(int count) {
+        MutableLiveData<List<PodcastEpisode>> liveNewestPodcastEpisodes = new MutableLiveData<>(new ArrayList<>());
+
+        App.getSubsonicClientInstance(false)
+                .getPodcastClient()
+                .getNewestPodcasts(count)
+                .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().getNewestPodcasts() != null) {
+                            liveNewestPodcastEpisodes.setValue(response.body().getSubsonicResponse().getNewestPodcasts().getEpisodes());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return liveNewestPodcastEpisodes;
+    }
+
+    public void refreshPodcasts() {
+        App.getSubsonicClientInstance(false)
+                .getPodcastClient()
+                .refreshPodcasts()
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public void createPodcastChannel(String url) {
+        App.getSubsonicClientInstance(false)
+                .getPodcastClient()
+                .createPodcastChannel(url)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public void deletePodcastChannel(String channelId) {
+        App.getSubsonicClientInstance(false)
+                .getPodcastClient()
+                .deletePodcastChannel(channelId)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public void deletePodcastEpisode(String episodeId) {
+        App.getSubsonicClientInstance(false)
+                .getPodcastClient()
+                .deletePodcastEpisode(episodeId)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public void downloadPodcastEpisode(String episodeId) {
+        App.getSubsonicClientInstance(false)
+                .getPodcastClient()
+                .downloadPodcastEpisode(episodeId)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+}

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

@@ -0,0 +1,378 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.database.AppDatabase;
+import com.cappielloantonio.tempo.database.dao.QueueDao;
+import com.cappielloantonio.tempo.model.Queue;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+import com.cappielloantonio.tempo.subsonic.models.Child;
+import com.cappielloantonio.tempo.subsonic.models.PlayQueue;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+public class QueueRepository {
+    private static final String TAG = "QueueRepository";
+
+    private final QueueDao queueDao = AppDatabase.getInstance().queueDao();
+
+    public LiveData<List<Queue>> getLiveQueue() {
+        return queueDao.getAll();
+    }
+
+    public List<Child> getMedia() {
+        List<Child> media = new ArrayList<>();
+
+        GetMediaThreadSafe getMedia = new GetMediaThreadSafe(queueDao);
+        Thread thread = new Thread(getMedia);
+        thread.start();
+
+        try {
+            thread.join();
+            media = getMedia.getMedia().stream()
+                    .map(Child.class::cast)
+                    .collect(Collectors.toList());
+
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        return media;
+    }
+
+    public MutableLiveData<PlayQueue> getPlayQueue() {
+        MutableLiveData<PlayQueue> playQueue = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBookmarksClient()
+                .getPlayQueue()
+                .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().getPlayQueue() != null) {
+                            playQueue.setValue(response.body().getSubsonicResponse().getPlayQueue());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        playQueue.setValue(null);
+                    }
+                });
+
+        return playQueue;
+    }
+
+    public void savePlayQueue(List<String> ids, String current, long position) {
+        App.getSubsonicClientInstance(false)
+                .getBookmarksClient()
+                .savePlayQueue(ids, current, position)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public void insert(Child media, boolean reset, int afterIndex) {
+        try {
+            List<Queue> mediaList = new ArrayList<>();
+
+            if (!reset) {
+                GetMediaThreadSafe getMediaThreadSafe = new GetMediaThreadSafe(queueDao);
+                Thread getMediaThread = new Thread(getMediaThreadSafe);
+                getMediaThread.start();
+                getMediaThread.join();
+
+                mediaList = getMediaThreadSafe.getMedia();
+            }
+
+            Queue queueItem = new Queue(media);
+            mediaList.add(afterIndex, queueItem);
+
+            for (int i = 0; i < mediaList.size(); i++) {
+                mediaList.get(i).setTrackOrder(i);
+            }
+
+            Thread delete = new Thread(new DeleteAllThreadSafe(queueDao));
+            delete.start();
+            delete.join();
+
+            Thread insertAll = new Thread(new InsertAllThreadSafe(queueDao, mediaList));
+            insertAll.start();
+            insertAll.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private boolean isMediaInQueue(List<Queue> queue, Child media) {
+        if (queue == null || media == null) return false;
+        
+        return queue.stream().anyMatch(queueItem -> 
+            queueItem != null && media.getId() != null && 
+            queueItem.getId().equals(media.getId())
+        );
+    }
+
+    public void insertAll(List<Child> toAdd, boolean reset, int afterIndex) {
+        try {
+            List<Queue> media = new ArrayList<>();
+
+            if (!reset) {
+                GetMediaThreadSafe getMediaThreadSafe = new GetMediaThreadSafe(queueDao);
+                Thread getMediaThread = new Thread(getMediaThreadSafe);
+                getMediaThread.start();
+                getMediaThread.join();
+
+                media = getMediaThreadSafe.getMedia();
+            }
+
+            List<Child> filteredToAdd = toAdd;
+            final List<Queue> finalMedia = media;
+            filteredToAdd = toAdd.stream()
+                .filter(child -> !isMediaInQueue(finalMedia, child))
+                .collect(Collectors.toList());
+
+            for (int i = 0; i < filteredToAdd.size(); i++) {
+                Queue queueItem = new Queue(filteredToAdd.get(i));
+                media.add(afterIndex + i, queueItem);
+            }
+
+            for (int i = 0; i < media.size(); i++) {
+                media.get(i).setTrackOrder(i);
+            }
+
+            Thread delete = new Thread(new DeleteAllThreadSafe(queueDao));
+            delete.start();
+            delete.join();
+
+            Thread insertAll = new Thread(new InsertAllThreadSafe(queueDao, media));
+            insertAll.start();
+            insertAll.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void delete(int position) {
+        DeleteThreadSafe delete = new DeleteThreadSafe(queueDao, position);
+        Thread thread = new Thread(delete);
+        thread.start();
+    }
+
+    public void deleteAll() {
+        DeleteAllThreadSafe deleteAll = new DeleteAllThreadSafe(queueDao);
+        Thread thread = new Thread(deleteAll);
+        thread.start();
+    }
+
+    public int count() {
+        int count = 0;
+
+        CountThreadSafe countThread = new CountThreadSafe(queueDao);
+        Thread thread = new Thread(countThread);
+        thread.start();
+
+        try {
+            thread.join();
+            count = countThread.getCount();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        return count;
+    }
+
+    public void setLastPlayedTimestamp(String id) {
+        SetLastPlayedTimestampThreadSafe timestamp = new SetLastPlayedTimestampThreadSafe(queueDao, id);
+        Thread thread = new Thread(timestamp);
+        thread.start();
+    }
+
+    public void setPlayingPausedTimestamp(String id, long ms) {
+        SetPlayingPausedTimestampThreadSafe timestamp = new SetPlayingPausedTimestampThreadSafe(queueDao, id, ms);
+        Thread thread = new Thread(timestamp);
+        thread.start();
+    }
+
+    public int getLastPlayedMediaIndex() {
+        int index = 0;
+
+        GetLastPlayedMediaThreadSafe getLastPlayedMediaThreadSafe = new GetLastPlayedMediaThreadSafe(queueDao);
+        Thread thread = new Thread(getLastPlayedMediaThreadSafe);
+        thread.start();
+
+        try {
+            thread.join();
+            Queue lastMediaPlayed = getLastPlayedMediaThreadSafe.getQueueItem();
+            index = lastMediaPlayed.getTrackOrder();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        return index;
+    }
+
+    public long getLastPlayedMediaTimestamp() {
+        long timestamp = 0;
+
+        GetLastPlayedMediaThreadSafe getLastPlayedMediaThreadSafe = new GetLastPlayedMediaThreadSafe(queueDao);
+        Thread thread = new Thread(getLastPlayedMediaThreadSafe);
+        thread.start();
+
+        try {
+            thread.join();
+            Queue lastMediaPlayed = getLastPlayedMediaThreadSafe.getQueueItem();
+            timestamp = lastMediaPlayed.getPlayingChanged();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        return timestamp;
+    }
+
+    private static class GetMediaThreadSafe implements Runnable {
+        private final QueueDao queueDao;
+        private List<Queue> media;
+
+        public GetMediaThreadSafe(QueueDao queueDao) {
+            this.queueDao = queueDao;
+        }
+
+        @Override
+        public void run() {
+            media = queueDao.getAllSimple();
+        }
+
+        public List<Queue> getMedia() {
+            return media;
+        }
+    }
+
+    private static class InsertAllThreadSafe implements Runnable {
+        private final QueueDao queueDao;
+        private final List<Queue> media;
+
+        public InsertAllThreadSafe(QueueDao queueDao, List<Queue> media) {
+            this.queueDao = queueDao;
+            this.media = media;
+        }
+
+        @Override
+        public void run() {
+            queueDao.insertAll(media);
+        }
+    }
+
+    private static class DeleteThreadSafe implements Runnable {
+        private final QueueDao queueDao;
+        private final int position;
+
+        public DeleteThreadSafe(QueueDao queueDao, int position) {
+            this.queueDao = queueDao;
+            this.position = position;
+        }
+
+        @Override
+        public void run() {
+            queueDao.delete(position);
+        }
+    }
+
+    private static class DeleteAllThreadSafe implements Runnable {
+        private final QueueDao queueDao;
+
+        public DeleteAllThreadSafe(QueueDao queueDao) {
+            this.queueDao = queueDao;
+        }
+
+        @Override
+        public void run() {
+            queueDao.deleteAll();
+        }
+    }
+
+    private static class CountThreadSafe implements Runnable {
+        private final QueueDao queueDao;
+        private int count = 0;
+
+        public CountThreadSafe(QueueDao queueDao) {
+            this.queueDao = queueDao;
+        }
+
+        @Override
+        public void run() {
+            count = queueDao.count();
+        }
+
+        public int getCount() {
+            return count;
+        }
+    }
+
+    private static class SetLastPlayedTimestampThreadSafe implements Runnable {
+        private final QueueDao queueDao;
+        private final String mediaId;
+
+        public SetLastPlayedTimestampThreadSafe(QueueDao queueDao, String mediaId) {
+            this.queueDao = queueDao;
+            this.mediaId = mediaId;
+        }
+
+        @Override
+        public void run() {
+            queueDao.setLastPlay(mediaId, System.currentTimeMillis());
+        }
+    }
+
+    private static class SetPlayingPausedTimestampThreadSafe implements Runnable {
+        private final QueueDao queueDao;
+        private final String mediaId;
+        private final long ms;
+
+        public SetPlayingPausedTimestampThreadSafe(QueueDao queueDao, String mediaId, long ms) {
+            this.queueDao = queueDao;
+            this.mediaId = mediaId;
+            this.ms = ms;
+        }
+
+        @Override
+        public void run() {
+            queueDao.setPlayingChanged(mediaId, ms);
+        }
+    }
+
+    private static class GetLastPlayedMediaThreadSafe implements Runnable {
+        private final QueueDao queueDao;
+        private Queue lastMediaPlayed;
+
+        public GetLastPlayedMediaThreadSafe(QueueDao queueDao) {
+            this.queueDao = queueDao;
+        }
+
+        @Override
+        public void run() {
+            lastMediaPlayed = queueDao.getLastPlayed();
+        }
+
+        public Queue getQueueItem() {
+            return lastMediaPlayed;
+        }
+    }
+}

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

@@ -0,0 +1,91 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.MutableLiveData;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+import com.cappielloantonio.tempo.subsonic.models.InternetRadioStation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+public class RadioRepository {
+    public MutableLiveData<List<InternetRadioStation>> getInternetRadioStations() {
+        MutableLiveData<List<InternetRadioStation>> radioStation = new MutableLiveData<>(new ArrayList<>());
+
+        App.getSubsonicClientInstance(false)
+                .getInternetRadioClient()
+                .getInternetRadioStations()
+                .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().getInternetRadioStations() != null && response.body().getSubsonicResponse().getInternetRadioStations().getInternetRadioStations() != null) {
+                            radioStation.setValue(response.body().getSubsonicResponse().getInternetRadioStations().getInternetRadioStations());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return radioStation;
+    }
+
+    public void createInternetRadioStation(String name, String streamURL, String homepageURL) {
+        App.getSubsonicClientInstance(false)
+                .getInternetRadioClient()
+                .createInternetRadioStation(streamURL, name, homepageURL)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public void updateInternetRadioStation(String id, String name, String streamURL, String homepageURL) {
+        App.getSubsonicClientInstance(false)
+                .getInternetRadioClient()
+                .updateInternetRadioStation(id, streamURL, name, homepageURL)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public void deleteInternetRadioStation(String id) {
+        App.getSubsonicClientInstance(false)
+                .getInternetRadioClient()
+                .deleteInternetRadioStation(id)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+}

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

@@ -0,0 +1,58 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.annotation.NonNull;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.interfaces.ScanCallback;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+
+public class ScanRepository {
+    public void startScan(ScanCallback callback) {
+        App.getSubsonicClientInstance(false)
+                .getMediaLibraryScanningClient()
+                .startScan()
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull retrofit2.Response<ApiResponse> response) {
+                        if (response.isSuccessful() && response.body() != null && response.body().getSubsonicResponse() != null) {
+                            if (response.body().getSubsonicResponse().getError() != null) {
+                                callback.onError(new Exception(response.body().getSubsonicResponse().getError().getMessage()));
+                            } else if (response.body().getSubsonicResponse().getScanStatus() != null) {
+                                callback.onSuccess(response.body().getSubsonicResponse().getScanStatus().isScanning(), response.body().getSubsonicResponse().getScanStatus().getCount());
+                            }
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        callback.onError(new Exception(t.getMessage()));
+                    }
+                });
+    }
+
+    public void getScanStatus(ScanCallback callback) {
+        App.getSubsonicClientInstance(false)
+                .getMediaLibraryScanningClient()
+                .startScan()
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull retrofit2.Response<ApiResponse> response) {
+                        if (response.isSuccessful() && response.body() != null && response.body().getSubsonicResponse() != null) {
+                            if (response.body().getSubsonicResponse().getError() != null) {
+                                callback.onError(new Exception(response.body().getSubsonicResponse().getError().getMessage()));
+                            } else if (response.body().getSubsonicResponse().getScanStatus() != null) {
+                                callback.onSuccess(response.body().getSubsonicResponse().getScanStatus().isScanning(), response.body().getSubsonicResponse().getScanStatus().getCount());
+                            }
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        callback.onError(new Exception(t.getMessage()));
+                    }
+                });
+    }
+}

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

@@ -0,0 +1,196 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.MutableLiveData;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.database.AppDatabase;
+import com.cappielloantonio.tempo.database.dao.RecentSearchDao;
+import com.cappielloantonio.tempo.model.RecentSearch;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+import com.cappielloantonio.tempo.subsonic.models.AlbumID3;
+import com.cappielloantonio.tempo.subsonic.models.ArtistID3;
+import com.cappielloantonio.tempo.subsonic.models.Child;
+import com.cappielloantonio.tempo.subsonic.models.SearchResult2;
+import com.cappielloantonio.tempo.subsonic.models.SearchResult3;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+public class SearchingRepository {
+    private final RecentSearchDao recentSearchDao = AppDatabase.getInstance().recentSearchDao();
+
+    public MutableLiveData<SearchResult2> search2(String query) {
+        MutableLiveData<SearchResult2> result = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getSearchingClient()
+                .search3(query, 20, 20, 20)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        if (response.isSuccessful() && response.body() != null) {
+                            result.setValue(response.body().getSubsonicResponse().getSearchResult2());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return result;
+    }
+
+    public MutableLiveData<SearchResult3> search3(String query) {
+        MutableLiveData<SearchResult3> result = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getSearchingClient()
+                .search3(query, 20, 20, 20)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        if (response.isSuccessful() && response.body() != null) {
+                            result.setValue(response.body().getSubsonicResponse().getSearchResult3());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return result;
+    }
+
+    public MutableLiveData<List<String>> getSuggestions(String query) {
+        MutableLiveData<List<String>> suggestions = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getSearchingClient()
+                .search3(query, 5, 5, 5)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        List<String> newSuggestions = new ArrayList();
+
+                        if (response.isSuccessful() && response.body() != null && response.body().getSubsonicResponse().getSearchResult3() != null) {
+                            if (response.body().getSubsonicResponse().getSearchResult3().getArtists() != null) {
+                                for (ArtistID3 artistID3 : response.body().getSubsonicResponse().getSearchResult3().getArtists()) {
+                                    newSuggestions.add(artistID3.getName());
+                                }
+                            }
+
+                            if (response.body().getSubsonicResponse().getSearchResult3().getAlbums() != null) {
+                                for (AlbumID3 albumID3 : response.body().getSubsonicResponse().getSearchResult3().getAlbums()) {
+                                    newSuggestions.add(albumID3.getName());
+                                }
+                            }
+
+                            if (response.body().getSubsonicResponse().getSearchResult3().getSongs() != null) {
+                                for (Child song : response.body().getSubsonicResponse().getSearchResult3().getSongs()) {
+                                    newSuggestions.add(song.getTitle());
+                                }
+                            }
+
+                            LinkedHashSet<String> hashSet = new LinkedHashSet<>(newSuggestions);
+                            ArrayList<String> suggestionsWithoutDuplicates = new ArrayList<>(hashSet);
+
+                            suggestions.setValue(suggestionsWithoutDuplicates);
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return suggestions;
+    }
+
+    public void insert(RecentSearch recentSearch) {
+        InsertThreadSafe insert = new InsertThreadSafe(recentSearchDao, recentSearch);
+        Thread thread = new Thread(insert);
+        thread.start();
+    }
+
+    public void delete(RecentSearch recentSearch) {
+        DeleteThreadSafe delete = new DeleteThreadSafe(recentSearchDao, recentSearch);
+        Thread thread = new Thread(delete);
+        thread.start();
+    }
+
+    public List<String> getRecentSearchSuggestion() {
+        List<String> recent = new ArrayList<>();
+
+        RecentThreadSafe suggestionsThread = new RecentThreadSafe(recentSearchDao);
+        Thread thread = new Thread(suggestionsThread);
+        thread.start();
+
+        try {
+            thread.join();
+            recent = suggestionsThread.getRecent();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        return recent;
+    }
+
+    private static class DeleteThreadSafe implements Runnable {
+        private final RecentSearchDao recentSearchDao;
+        private final RecentSearch recentSearch;
+
+        public DeleteThreadSafe(RecentSearchDao recentSearchDao, RecentSearch recentSearch) {
+            this.recentSearchDao = recentSearchDao;
+            this.recentSearch = recentSearch;
+        }
+
+        @Override
+        public void run() {
+            recentSearchDao.delete(recentSearch);
+        }
+    }
+
+    private static class InsertThreadSafe implements Runnable {
+        private final RecentSearchDao recentSearchDao;
+        private final RecentSearch recentSearch;
+
+        public InsertThreadSafe(RecentSearchDao recentSearchDao, RecentSearch recentSearch) {
+            this.recentSearchDao = recentSearchDao;
+            this.recentSearch = recentSearch;
+        }
+
+        @Override
+        public void run() {
+            recentSearchDao.insert(recentSearch);
+        }
+    }
+
+    private static class RecentThreadSafe implements Runnable {
+        private final RecentSearchDao recentSearchDao;
+        private List<String> recent = new ArrayList<>();
+
+        public RecentThreadSafe(RecentSearchDao recentSearchDao) {
+            this.recentSearchDao = recentSearchDao;
+        }
+
+        @Override
+        public void run() {
+            recent = recentSearchDao.getRecent();
+        }
+
+        public List<String> getRecent() {
+            return recent;
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.lifecycle.LiveData;
+
+import com.cappielloantonio.tempo.database.AppDatabase;
+import com.cappielloantonio.tempo.database.dao.ServerDao;
+import com.cappielloantonio.tempo.model.Server;
+
+import java.util.List;
+
+public class ServerRepository {
+    private static final String TAG = "QueueRepository";
+
+    private final ServerDao serverDao = AppDatabase.getInstance().serverDao();
+
+    public LiveData<List<Server>> getLiveServer() {
+        return serverDao.getAll();
+    }
+
+    public void insert(Server server) {
+        InsertThreadSafe insert = new InsertThreadSafe(serverDao, server);
+        Thread thread = new Thread(insert);
+        thread.start();
+    }
+
+    public void delete(Server server) {
+        DeleteThreadSafe delete = new DeleteThreadSafe(serverDao, server);
+        Thread thread = new Thread(delete);
+        thread.start();
+    }
+
+    private static class InsertThreadSafe implements Runnable {
+        private final ServerDao serverDao;
+        private final Server server;
+
+        public InsertThreadSafe(ServerDao serverDao, Server server) {
+            this.serverDao = serverDao;
+            this.server = server;
+        }
+
+        @Override
+        public void run() {
+            serverDao.insert(server);
+        }
+    }
+
+    private static class DeleteThreadSafe implements Runnable {
+        private final ServerDao serverDao;
+        private final Server server;
+
+        public DeleteThreadSafe(ServerDao serverDao, Server server) {
+            this.serverDao = serverDao;
+            this.server = server;
+        }
+
+        @Override
+        public void run() {
+            serverDao.delete(server);
+        }
+    }
+}

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

@@ -0,0 +1,99 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.MutableLiveData;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+import com.cappielloantonio.tempo.subsonic.models.Share;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+public class SharingRepository {
+    public MutableLiveData<List<Share>> getShares() {
+        MutableLiveData<List<Share>> shares = new MutableLiveData<>(new ArrayList<>());
+
+        App.getSubsonicClientInstance(false)
+                .getSharingClient()
+                .getShares()
+                .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().getShares() != null && response.body().getSubsonicResponse().getShares().getShares() != null) {
+                            shares.setValue(response.body().getSubsonicResponse().getShares().getShares());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return shares;
+    }
+
+    public MutableLiveData<Share> createShare(String id, String description, Long expires) {
+        MutableLiveData<Share> share = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getSharingClient()
+                .createShare(id, description, expires)
+                .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().getShares() != null && response.body().getSubsonicResponse().getShares().getShares() != null && response.body().getSubsonicResponse().getShares().getShares().get(0) != null) {
+                            share.setValue(response.body().getSubsonicResponse().getShares().getShares().get(0));
+                        } else {
+                            share.setValue(null);
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        share.setValue(null);
+                    }
+                });
+
+        return share;
+    }
+
+    public void updateShare(String id, String description, Long expires) {
+        App.getSubsonicClientInstance(false)
+                .getSharingClient()
+                .updateShare(id, description, expires)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public void deleteShare(String id) {
+        App.getSubsonicClientInstance(false)
+                .getSharingClient()
+                .deleteShare(id)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+}

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

@@ -0,0 +1,260 @@
+package com.cappielloantonio.tempo.repository;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.MutableLiveData;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+import com.cappielloantonio.tempo.subsonic.models.Child;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+public class SongRepository {
+    private static final String TAG = "SongRepository";
+
+    public MutableLiveData<List<Child>> getStarredSongs(boolean random, int size) {
+        MutableLiveData<List<Child>> starredSongs = new MutableLiveData<>(Collections.emptyList());
+
+        App.getSubsonicClientInstance(false)
+                .getAlbumSongListClient()
+                .getStarred2()
+                .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().getStarred2() != null) {
+                            List<Child> songs = response.body().getSubsonicResponse().getStarred2().getSongs();
+
+                            if (songs != null) {
+                                if (!random) {
+                                    starredSongs.setValue(songs);
+                                } else {
+                                    Collections.shuffle(songs);
+                                    starredSongs.setValue(songs.subList(0, Math.min(size, songs.size())));
+                                }
+                            }
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return starredSongs;
+    }
+
+    public MutableLiveData<List<Child>> getInstantMix(String id, int count) {
+        MutableLiveData<List<Child>> instantMix = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getSimilarSongs2(id, count)
+                .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().getSimilarSongs2() != null) {
+                            instantMix.setValue(response.body().getSubsonicResponse().getSimilarSongs2().getSongs());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        instantMix.setValue(null);
+                    }
+                });
+
+        return instantMix;
+    }
+
+    public MutableLiveData<List<Child>> getRandomSample(int number, Integer fromYear, Integer toYear) {
+        MutableLiveData<List<Child>> randomSongsSample = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getAlbumSongListClient()
+                .getRandomSongs(number, fromYear, toYear)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        List<Child> songs = new ArrayList<>();
+
+                        if (response.isSuccessful() && response.body() != null && response.body().getSubsonicResponse().getRandomSongs() != null && response.body().getSubsonicResponse().getRandomSongs().getSongs() != null) {
+                            songs.addAll(response.body().getSubsonicResponse().getRandomSongs().getSongs());
+                        }
+
+                        randomSongsSample.setValue(songs);
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return randomSongsSample;
+    }
+
+    public MutableLiveData<List<Child>> getRandomSampleWithGenre(int number, Integer fromYear, Integer toYear, String genre) {
+        MutableLiveData<List<Child>> randomSongsSample = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getAlbumSongListClient()
+                .getRandomSongs(number, fromYear, toYear, genre)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        List<Child> songs = new ArrayList<>();
+
+                        if (response.isSuccessful() && response.body() != null && response.body().getSubsonicResponse().getRandomSongs() != null && response.body().getSubsonicResponse().getRandomSongs().getSongs() != null) {
+                            songs.addAll(response.body().getSubsonicResponse().getRandomSongs().getSongs());
+                        }
+
+                        randomSongsSample.setValue(songs);
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return randomSongsSample;
+    }
+
+    public void scrobble(String id, boolean submission) {
+        App.getSubsonicClientInstance(false)
+                .getMediaAnnotationClient()
+                .scrobble(id, submission)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public void setRating(String id, int rating) {
+        App.getSubsonicClientInstance(false)
+                .getMediaAnnotationClient()
+                .setRating(id, rating)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+    }
+
+    public MutableLiveData<List<Child>> getSongsByGenre(String id, int page) {
+        MutableLiveData<List<Child>> songsByGenre = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getAlbumSongListClient()
+                .getSongsByGenre(id, 100, 100 * page)
+                .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().getSongsByGenre() != null) {
+                            songsByGenre.setValue(response.body().getSubsonicResponse().getSongsByGenre().getSongs());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return songsByGenre;
+    }
+
+    public MutableLiveData<List<Child>> getSongsByGenres(ArrayList<String> genresId) {
+        MutableLiveData<List<Child>> songsByGenre = new MutableLiveData<>();
+
+        for (String id : genresId)
+            App.getSubsonicClientInstance(false)
+                    .getAlbumSongListClient()
+                    .getSongsByGenre(id, 500, 0)
+                    .enqueue(new Callback<ApiResponse>() {
+                        @Override
+                        public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                            List<Child> songs = new ArrayList<>();
+
+                            if (response.isSuccessful() && response.body() != null && response.body().getSubsonicResponse().getSongsByGenre() != null) {
+                                songs.addAll(response.body().getSubsonicResponse().getSongsByGenre().getSongs());
+                            }
+
+                            songsByGenre.setValue(songs);
+                        }
+
+                        @Override
+                        public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                        }
+                    });
+
+        return songsByGenre;
+    }
+
+    public MutableLiveData<Child> getSong(String id) {
+        MutableLiveData<Child> song = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getBrowsingClient()
+                .getSong(id)
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        if (response.isSuccessful() && response.body() != null) {
+                            song.setValue(response.body().getSubsonicResponse().getSong());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return song;
+    }
+
+    public MutableLiveData<String> getSongLyrics(Child song) {
+        MutableLiveData<String> lyrics = new MutableLiveData<>(null);
+
+        App.getSubsonicClientInstance(false)
+                .getMediaRetrievalClient()
+                .getLyrics(song.getArtist(), song.getTitle())
+                .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().getLyrics() != null) {
+                            lyrics.setValue(response.body().getSubsonicResponse().getLyrics().getValue());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+
+                    }
+                });
+
+        return lyrics;
+    }
+}

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

@@ -0,0 +1,123 @@
+package com.cappielloantonio.tempo.repository;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.MutableLiveData;
+
+import com.cappielloantonio.tempo.App;
+import com.cappielloantonio.tempo.github.models.LatestRelease;
+import com.cappielloantonio.tempo.interfaces.SystemCallback;
+import com.cappielloantonio.tempo.subsonic.base.ApiResponse;
+import com.cappielloantonio.tempo.subsonic.models.OpenSubsonicExtension;
+import com.cappielloantonio.tempo.subsonic.models.ResponseStatus;
+import com.cappielloantonio.tempo.subsonic.models.SubsonicResponse;
+
+import java.util.List;
+
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+
+public class SystemRepository {
+    public void checkUserCredential(SystemCallback callback) {
+        App.getSubsonicClientInstance(false)
+                .getSystemClient()
+                .ping()
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull retrofit2.Response<ApiResponse> response) {
+                        if (response.body() != null) {
+                            if (response.body().getSubsonicResponse().getStatus().equals(ResponseStatus.FAILED)) {
+                                callback.onError(new Exception(response.body().getSubsonicResponse().getError().getCode() + " - " + response.body().getSubsonicResponse().getError().getMessage()));
+                            } else if (response.body().getSubsonicResponse().getStatus().equals(ResponseStatus.OK)) {
+                                String password = response.raw().request().url().queryParameter("p");
+                                String token = response.raw().request().url().queryParameter("t");
+                                String salt = response.raw().request().url().queryParameter("s");
+                                callback.onSuccess(password, token, salt);
+                            } else {
+                                callback.onError(new Exception("Empty response"));
+                            }
+                        } else {
+                            callback.onError(new Exception(String.valueOf(response.code())));
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        callback.onError(new Exception(t.getMessage()));
+                    }
+                });
+    }
+
+    public MutableLiveData<SubsonicResponse> ping() {
+        MutableLiveData<SubsonicResponse> pingResult = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getSystemClient()
+                .ping()
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        if (response.isSuccessful() && response.body() != null) {
+                            pingResult.postValue(response.body().getSubsonicResponse());
+                        } else {
+                            pingResult.postValue(null);
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        pingResult.postValue(null);
+                    }
+                });
+
+        return pingResult;
+    }
+
+    public MutableLiveData<List<OpenSubsonicExtension>> getOpenSubsonicExtensions() {
+        MutableLiveData<List<OpenSubsonicExtension>> extensionsResult = new MutableLiveData<>();
+
+        App.getSubsonicClientInstance(false)
+                .getSystemClient()
+                .getOpenSubsonicExtensions()
+                .enqueue(new Callback<ApiResponse>() {
+                    @Override
+                    public void onResponse(@NonNull Call<ApiResponse> call, @NonNull Response<ApiResponse> response) {
+                        if (response.isSuccessful() && response.body() != null) {
+                            extensionsResult.postValue(response.body().getSubsonicResponse().getOpenSubsonicExtensions());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<ApiResponse> call, @NonNull Throwable t) {
+                        extensionsResult.postValue(null);
+                    }
+                });
+
+        return extensionsResult;
+    }
+
+    public MutableLiveData<LatestRelease> checkTempoUpdate() {
+        MutableLiveData<LatestRelease> latestRelease = new MutableLiveData<>();
+
+        App.getGithubClientInstance()
+                .getReleaseClient()
+                .getLatestRelease()
+                .enqueue(new Callback<LatestRelease>() {
+                    @Override
+                    public void onResponse(@NonNull Call<LatestRelease> call, @NonNull Response<LatestRelease> response) {
+                        if (response.isSuccessful() && response.body() != null) {
+                            latestRelease.postValue(response.body());
+                        }
+                    }
+
+                    @Override
+                    public void onFailure(@NonNull Call<LatestRelease> call, @NonNull Throwable t) {
+                        latestRelease.postValue(null);
+                    }
+                });
+
+        return latestRelease;
+    }
+}

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

@@ -0,0 +1,148 @@
+package com.cappielloantonio.tempo.service;
+
+import static androidx.media3.common.util.Assertions.checkNotNull;
+
+import android.content.Context;
+
+import androidx.annotation.Nullable;
+import androidx.media3.common.MediaItem;
+import androidx.media3.common.util.Log;
+import androidx.media3.common.util.UnstableApi;
+import androidx.media3.common.util.Util;
+import androidx.media3.datasource.DataSource;
+import androidx.media3.exoplayer.offline.Download;
+import androidx.media3.exoplayer.offline.DownloadCursor;
+import androidx.media3.exoplayer.offline.DownloadHelper;
+import androidx.media3.exoplayer.offline.DownloadIndex;
+import androidx.media3.exoplayer.offline.DownloadManager;
+import androidx.media3.exoplayer.offline.DownloadRequest;
+import androidx.media3.exoplayer.offline.DownloadService;
+
+import com.cappielloantonio.tempo.repository.DownloadRepository;
+import com.cappielloantonio.tempo.util.DownloadUtil;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+
+@UnstableApi
+public class DownloaderManager {
+    private static final String TAG = "DownloaderManager";
+
+    private final Context context;
+    private final DataSource.Factory dataSourceFactory;
+    private final DownloadIndex downloadIndex;
+
+    private static HashMap<String, Download> downloads;
+
+    public DownloaderManager(Context context, DataSource.Factory dataSourceFactory, DownloadManager downloadManager) {
+        this.context = context.getApplicationContext();
+        this.dataSourceFactory = dataSourceFactory;
+
+        downloads = new HashMap<>();
+        downloadIndex = downloadManager.getDownloadIndex();
+
+        loadDownloads();
+    }
+
+    private DownloadRequest buildDownloadRequest(MediaItem mediaItem) {
+        return DownloadHelper
+                .forMediaItem(
+                        context,
+                        mediaItem,
+                        DownloadUtil.buildRenderersFactory(context, false),
+                        dataSourceFactory)
+                .getDownloadRequest(Util.getUtf8Bytes(checkNotNull(mediaItem.mediaId)))
+                .copyWithId(mediaItem.mediaId);
+    }
+
+    public boolean isDownloaded(String mediaId) {
+        @Nullable Download download = downloads.get(mediaId);
+        return download != null && download.state != Download.STATE_FAILED;
+    }
+
+    public boolean isDownloaded(MediaItem mediaItem) {
+        return isDownloaded(mediaItem.mediaId);
+    }
+
+    public boolean areDownloaded(List<MediaItem> mediaItems) {
+        return mediaItems.stream().anyMatch(this::isDownloaded);
+    }
+
+    public void download(MediaItem mediaItem, com.cappielloantonio.tempo.model.Download download) {
+        download.setDownloadUri(mediaItem.requestMetadata.mediaUri.toString());
+
+        DownloadService.sendAddDownload(context, DownloaderService.class, buildDownloadRequest(mediaItem), false);
+        insertDatabase(download);
+    }
+
+    public void download(List<MediaItem> mediaItems, List<com.cappielloantonio.tempo.model.Download> downloads) {
+        for (int counter = 0; counter < mediaItems.size(); counter++) {
+            download(mediaItems.get(counter), downloads.get(counter));
+        }
+    }
+
+    public void remove(MediaItem mediaItem, com.cappielloantonio.tempo.model.Download download) {
+        DownloadService.sendRemoveDownload(context, DownloaderService.class, buildDownloadRequest(mediaItem).id, false);
+        deleteDatabase(download.getId());
+        downloads.remove(download.getId());
+    }
+
+    public void remove(List<MediaItem> mediaItems, List<com.cappielloantonio.tempo.model.Download> downloads) {
+        for (int counter = 0; counter < mediaItems.size(); counter++) {
+            remove(mediaItems.get(counter), downloads.get(counter));
+        }
+    }
+
+    public void removeAll() {
+        DownloadService.sendRemoveAllDownloads(context, DownloaderService.class, false);
+        deleteAllDatabase();
+        DownloadUtil.eraseDownloadFolder(context);
+    }
+
+    private void loadDownloads() {
+        try (DownloadCursor loadedDownloads = downloadIndex.getDownloads()) {
+            while (loadedDownloads.moveToNext()) {
+                Download download = loadedDownloads.getDownload();
+                downloads.put(download.request.id, download);
+            }
+        } catch (IOException e) {
+            Log.w(TAG, "Failed to query downloads", e);
+        }
+    }
+
+    public static String getDownloadNotificationMessage(String id) {
+        com.cappielloantonio.tempo.model.Download download = getDownloadRepository().getDownload(id);
+        return download != null ? download.getTitle() : null;
+    }
+
+    public static void updateRequestDownload(Download download) {
+        updateDatabase(download.request.id);
+        downloads.put(download.request.id, download);
+    }
+
+    public static void removeRequestDownload(Download download) {
+        deleteDatabase(download.request.id);
+        downloads.remove(download.request.id);
+    }
+
+    private static DownloadRepository getDownloadRepository() {
+        return new DownloadRepository();
+    }
+
+    private static void insertDatabase(com.cappielloantonio.tempo.model.Download download) {
+        getDownloadRepository().insert(download);
+    }
+
+    private static void deleteDatabase(String id) {
+        getDownloadRepository().delete(id);
+    }
+
+    private static void deleteAllDatabase() {
+        getDownloadRepository().deleteAll();
+    }
+
+    private static void updateDatabase(String id) {
+        getDownloadRepository().update(id);
+    }
+}

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

@@ -0,0 +1,115 @@
+package com.cappielloantonio.tempo.service;
+
+import android.app.Notification;
+import android.content.Context;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.media3.common.util.NotificationUtil;
+import androidx.media3.common.util.UnstableApi;
+import androidx.media3.exoplayer.offline.Download;
+import androidx.media3.exoplayer.offline.DownloadManager;
+import androidx.media3.exoplayer.offline.DownloadNotificationHelper;
+import androidx.media3.exoplayer.scheduler.PlatformScheduler;
+import androidx.media3.exoplayer.scheduler.Requirements;
+import androidx.media3.exoplayer.scheduler.Scheduler;
+
+import com.cappielloantonio.tempo.R;
+import com.cappielloantonio.tempo.util.DownloadUtil;
+
+import java.util.List;
+
+@UnstableApi
+public class DownloaderService extends androidx.media3.exoplayer.offline.DownloadService {
+
+    private static final int JOB_ID = 1;
+    private static final int FOREGROUND_NOTIFICATION_ID = 1;
+
+    public DownloaderService() {
+        super(FOREGROUND_NOTIFICATION_ID, DEFAULT_FOREGROUND_NOTIFICATION_UPDATE_INTERVAL, DownloadUtil.DOWNLOAD_NOTIFICATION_CHANNEL_ID, R.string.exo_download_notification_channel_name, 0);
+    }
+
+    @NonNull
+    @Override
+    protected DownloadManager getDownloadManager() {
+        DownloadManager downloadManager = DownloadUtil.getDownloadManager(this);
+        DownloadNotificationHelper downloadNotificationHelper = DownloadUtil.getDownloadNotificationHelper(this);
+        downloadManager.addListener(new TerminalStateNotificationHelper(this, downloadNotificationHelper, FOREGROUND_NOTIFICATION_ID + 1));
+        return downloadManager;
+    }
+
+    @NonNull
+    @Override
+    protected Scheduler getScheduler() {
+        return new PlatformScheduler(this, JOB_ID);
+    }
+
+    @NonNull
+    @Override
+    protected Notification getForegroundNotification(@NonNull List<Download> downloads, @Requirements.RequirementFlags int notMetRequirements) {
+        return DownloadUtil.getDownloadNotificationHelper(this).buildProgressNotification(this, R.drawable.ic_download, null, null, downloads, notMetRequirements);
+    }
+
+    private static final class TerminalStateNotificationHelper implements DownloadManager.Listener {
+        private final Context context;
+        private final DownloadNotificationHelper notificationHelper;
+
+        private final Notification successfulDownloadGroupNotification;
+        private final Notification failedDownloadGroupNotification;
+
+        private final int successfulDownloadGroupNotificationId;
+        private final int failedDownloadGroupNotificationId;
+
+        private int nextNotificationId;
+
+        public TerminalStateNotificationHelper(Context context, DownloadNotificationHelper notificationHelper, int firstNotificationId) {
+            this.context = context.getApplicationContext();
+            this.notificationHelper = notificationHelper;
+            nextNotificationId = firstNotificationId;
+
+            successfulDownloadGroupNotification = DownloadUtil.buildGroupSummaryNotification(
+                    this.context,
+                    DownloadUtil.DOWNLOAD_NOTIFICATION_CHANNEL_ID,
+                    DownloadUtil.DOWNLOAD_NOTIFICATION_SUCCESSFUL_GROUP,
+                    R.drawable.ic_check_circle,
+                    "Downloads completed"
+            );
+
+            failedDownloadGroupNotification = DownloadUtil.buildGroupSummaryNotification(
+                    this.context,
+                    DownloadUtil.DOWNLOAD_NOTIFICATION_CHANNEL_ID,
+                    DownloadUtil.DOWNLOAD_NOTIFICATION_FAILED_GROUP,
+                    R.drawable.ic_error,
+                    "Downloads failed"
+            );
+
+            successfulDownloadGroupNotificationId = nextNotificationId++;
+            failedDownloadGroupNotificationId = nextNotificationId++;
+        }
+
+        @Override
+        public void onDownloadChanged(@NonNull DownloadManager downloadManager, Download download, @Nullable Exception finalException) {
+            Notification notification;
+
+            if (download.state == Download.STATE_COMPLETED) {
+                notification = notificationHelper.buildDownloadCompletedNotification(context, R.drawable.ic_check_circle, null, DownloaderManager.getDownloadNotificationMessage(download.request.id));
+                notification = Notification.Builder.recoverBuilder(context, notification).setGroup(DownloadUtil.DOWNLOAD_NOTIFICATION_SUCCESSFUL_GROUP).build();
+                NotificationUtil.setNotification(this.context, successfulDownloadGroupNotificationId, successfulDownloadGroupNotification);
+                DownloaderManager.updateRequestDownload(download);
+            } else if (download.state == Download.STATE_FAILED) {
+                notification = notificationHelper.buildDownloadFailedNotification(context, R.drawable.ic_error, null, DownloaderManager.getDownloadNotificationMessage(download.request.id));
+                notification = Notification.Builder.recoverBuilder(context, notification).setGroup(DownloadUtil.DOWNLOAD_NOTIFICATION_FAILED_GROUP).build();
+                NotificationUtil.setNotification(this.context, failedDownloadGroupNotificationId, failedDownloadGroupNotification);
+            } else {
+                return;
+            }
+
+            NotificationUtil.setNotification(context, nextNotificationId++, notification);
+        }
+
+        @Override
+        public void onDownloadRemoved(@NonNull DownloadManager downloadManager, Download download) {
+            DownloaderManager.removeRequestDownload(download);
+        }
+    }
+}

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
+    }
+}