app/src/main/java/audio/funkwhale/ffa/fragments/RadiosFragment.kt

@@ -9,12 +9,12 @@ import androidx.lifecycle.lifecycleScope
 import androidx.recyclerview.widget.RecyclerView
 import audio.funkwhale.ffa.adapters.RadiosAdapter
 import audio.funkwhale.ffa.databinding.FragmentRadiosBinding
+import audio.funkwhale.ffa.model.Radio
 import audio.funkwhale.ffa.repositories.RadiosRepository
 import audio.funkwhale.ffa.utils.Command
 import audio.funkwhale.ffa.utils.CommandBus
 import audio.funkwhale.ffa.utils.Event
 import audio.funkwhale.ffa.utils.EventBus
-import audio.funkwhale.ffa.model.Radio
 import kotlinx.coroutines.Dispatchers.Main
 import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.launch
@@ -62,8 +62,7 @@ class RadiosFragment : FFAFragment<Radio, RadiosAdapter>() {
 
       lifecycleScope.launch(Main) {
         EventBus.get().collect { message ->
-          when (message) {
-            is Event.RadioStarted ->
+          if (message is Event.RadioStarted) {
             recycler.forEach {
               it.isEnabled = true
               it.isClickable = true

app/src/main/java/audio/funkwhale/ffa/activities/SearchActivity.kt → app/src/main/java/audio/funkwhale/ffa/fragments/SearchFragment.kt

-package audio.funkwhale.ffa.activities
+package audio.funkwhale.ffa.fragments
 
 import android.os.Bundle
+import android.view.LayoutInflater
 import android.view.View
-import androidx.appcompat.app.AppCompatActivity
+import android.view.ViewGroup
+import androidx.appcompat.widget.SearchView
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
 import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.lifecycleScope
+import androidx.navigation.fragment.findNavController
 import androidx.recyclerview.widget.LinearLayoutManager
+import audio.funkwhale.ffa.adapters.FavoriteListener
 import audio.funkwhale.ffa.adapters.SearchAdapter
-import audio.funkwhale.ffa.databinding.ActivitySearchBinding
-import audio.funkwhale.ffa.fragments.AddToPlaylistDialog
-import audio.funkwhale.ffa.fragments.AlbumsFragment
-import audio.funkwhale.ffa.fragments.ArtistsFragment
+import audio.funkwhale.ffa.databinding.FragmentSearchBinding
 import audio.funkwhale.ffa.model.Album
 import audio.funkwhale.ffa.model.Artist
-import audio.funkwhale.ffa.repositories.*
-import audio.funkwhale.ffa.utils.*
+import audio.funkwhale.ffa.repositories.FavoritesRepository
+import audio.funkwhale.ffa.utils.Command
+import audio.funkwhale.ffa.utils.CommandBus
+import audio.funkwhale.ffa.utils.Event
+import audio.funkwhale.ffa.utils.EventBus
+import audio.funkwhale.ffa.utils.getMetadata
+import audio.funkwhale.ffa.viewmodel.SearchViewModel
 import com.google.android.exoplayer2.offline.Download
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import java.net.URLEncoder
-import java.util.*
 
-class SearchActivity : AppCompatActivity() {
+class SearchFragment : Fragment() {
   private lateinit var adapter: SearchAdapter
-
-  private lateinit var artistsRepository: ArtistsSearchRepository
-  private lateinit var albumsRepository: AlbumsSearchRepository
-  private lateinit var tracksRepository: TracksSearchRepository
-  private lateinit var favoritesRepository: FavoritesRepository
-  private lateinit var binding: ActivitySearchBinding
-
-  var done = 0
-
-  override fun onCreate(savedInstanceState: Bundle?) {
-    super.onCreate(savedInstanceState)
-
-    binding = ActivitySearchBinding.inflate(layoutInflater)
-
-    setContentView(binding.root)
-
-    adapter =
-      SearchAdapter(layoutInflater, this, SearchResultClickListener(), FavoriteListener()).also {
-        binding.results.layoutManager = LinearLayoutManager(this)
-        binding.results.adapter = it
-      }
-
-    binding.search.requestFocus()
+  private lateinit var binding: FragmentSearchBinding
+  private val viewModel by activityViewModels<SearchViewModel>()
+  private val noSearchYet = MutableLiveData(true)
+
+  override fun onCreateView(
+    inflater: LayoutInflater,
+    container: ViewGroup?,
+    savedInstanceState: Bundle?
+  ): View {
+    binding = FragmentSearchBinding.inflate(layoutInflater, container, false)
+    binding.lifecycleOwner = this
+    binding.isLoadingData = viewModel.isLoadingData
+    binding.hasResults = viewModel.hasResults
+    binding.noSearchYet = noSearchYet
+    return binding.root
   }
 
   override fun onResume() {
     super.onResume()
+    binding.search.requestFocus()
 
     lifecycleScope.launch(Dispatchers.Main) {
       CommandBus.get().collect { command ->
-        when (command) {
-          is Command.AddToPlaylist -> if (lifecycle.currentState.isAtLeast(Lifecycle.State.RESUMED)) {
+        if (command is Command.AddToPlaylist) {
+
+          if (lifecycle.currentState.isAtLeast(Lifecycle.State.RESUMED)) {
             AddToPlaylistDialog.show(
               layoutInflater,
-              this@SearchActivity,
+              requireActivity(),
               lifecycleScope,
               command.tracks
             )
@@ -69,85 +69,40 @@ class SearchActivity : AppCompatActivity() {
     }
 
     lifecycleScope.launch(Dispatchers.IO) {
-      EventBus.get().collect { message ->
-        when (message) {
-          is Event.DownloadChanged -> refreshDownloadedTrack(message.download)
+      EventBus.get().collect { event ->
+        if (event is Event.DownloadChanged) refreshDownloadedTrack(event.download)
       }
     }
-    }
-
-    artistsRepository = ArtistsSearchRepository(this@SearchActivity, "")
-    albumsRepository = AlbumsSearchRepository(this@SearchActivity, "")
-    tracksRepository = TracksSearchRepository(this@SearchActivity, "")
-    favoritesRepository = FavoritesRepository(this@SearchActivity)
-
-    binding.search.setOnQueryTextListener(object :
-      androidx.appcompat.widget.SearchView.OnQueryTextListener {
-      override fun onQueryTextSubmit(rawQuery: String?): Boolean {
-        binding.search.clearFocus()
-
-        rawQuery?.let {
-          done = 0
-
-          val query = URLEncoder.encode(it, "UTF-8")
-
-          artistsRepository.query = query.lowercase(Locale.ROOT)
-          albumsRepository.query = query.lowercase(Locale.ROOT)
-          tracksRepository.query = query.lowercase(Locale.ROOT)
 
-          binding.searchSpinner.visibility = View.VISIBLE
-          binding.searchEmpty.visibility = View.GONE
-          binding.searchNoResults.visibility = View.GONE
-
-          adapter.artists.clear()
-          adapter.albums.clear()
-          adapter.tracks.clear()
-          adapter.notifyDataSetChanged()
-
-          artistsRepository.fetch(Repository.Origin.Network.origin)
-            .untilNetwork(lifecycleScope) { artists, _, _, _ ->
-              done++
-
-              adapter.artists.addAll(artists)
-              refresh()
-            }
-
-          albumsRepository.fetch(Repository.Origin.Network.origin)
-            .untilNetwork(lifecycleScope) { albums, _, _, _ ->
-              done++
-
-              adapter.albums.addAll(albums)
-              refresh()
+    adapter =
+      SearchAdapter(
+        viewModel,
+        this,
+        SearchResultClickListener(),
+        FavoriteListener(FavoritesRepository(requireContext()))
+      ).also {
+        binding.results.layoutManager = LinearLayoutManager(requireContext())
+        binding.results.adapter = it
       }
 
-          tracksRepository.fetch(Repository.Origin.Network.origin)
-            .untilNetwork(lifecycleScope) { tracks, _, _, _ ->
-              done++
+    binding.search.setOnQueryTextListener(object : SearchView.OnQueryTextListener {
 
-              adapter.tracks.addAll(tracks)
-              refresh()
-            }
-        }
+      override fun onQueryTextSubmit(query: String): Boolean {
+        binding.search.clearFocus()
+        noSearchYet.value = false
+        viewModel.query.postValue(query)
 
         return true
       }
 
-      override fun onQueryTextChange(newText: String?) = true
+      override fun onQueryTextChange(newText: String) = true
     })
   }
 
-  private fun refresh() {
-    adapter.notifyDataSetChanged()
-
-    if (adapter.artists.size + adapter.albums.size + adapter.tracks.size == 0) {
-      binding.searchNoResults.visibility = View.VISIBLE
-    } else {
-      binding.searchNoResults.visibility = View.GONE
-    }
-
-    if (done == 3) {
-      binding.searchSpinner.visibility = View.INVISIBLE
-    }
+  override fun onDestroy() {
+    super.onDestroy()
+    // Empty the research to prevent result recall the next time
+    viewModel.query.value = ""
   }
 
   private suspend fun refreshDownloadedTrack(download: Download) {
@@ -171,20 +126,11 @@ class SearchActivity : AppCompatActivity() {
 
   inner class SearchResultClickListener : SearchAdapter.OnSearchResultClickListener {
     override fun onArtistClick(holder: View?, artist: Artist) {
-      ArtistsFragment.openAlbums(this@SearchActivity, artist)
+      findNavController().navigate(SearchFragmentDirections.searchToAlbums(artist))
     }
 
     override fun onAlbumClick(holder: View?, album: Album) {
-      AlbumsFragment.openTracks(this@SearchActivity, album)
-    }
-  }
-
-  inner class FavoriteListener : SearchAdapter.OnFavoriteListener {
-    override fun onToggleFavorite(id: Int, state: Boolean) {
-      when (state) {
-        true -> favoritesRepository.addFavorite(id)
-        false -> favoritesRepository.deleteFavorite(id)
-      }
+      findNavController().navigate(SearchFragmentDirections.searchToTracks(album))
     }
   }
 }

app/src/main/java/audio/funkwhale/ffa/fragments/TracksFragment.kt

@@ -8,32 +8,41 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.appcompat.widget.PopupMenu
-import androidx.core.os.bundleOf
 import androidx.lifecycle.lifecycleScope
+import androidx.navigation.fragment.navArgs
 import androidx.recyclerview.widget.RecyclerView
 import audio.funkwhale.ffa.R
+import audio.funkwhale.ffa.adapters.FavoriteListener
 import audio.funkwhale.ffa.adapters.TracksAdapter
 import audio.funkwhale.ffa.databinding.FragmentTracksBinding
-import audio.funkwhale.ffa.model.Album
 import audio.funkwhale.ffa.model.Track
 import audio.funkwhale.ffa.repositories.FavoritedRepository
 import audio.funkwhale.ffa.repositories.FavoritesRepository
 import audio.funkwhale.ffa.repositories.TracksRepository
-import audio.funkwhale.ffa.utils.*
+import audio.funkwhale.ffa.utils.Command
+import audio.funkwhale.ffa.utils.CommandBus
+import audio.funkwhale.ffa.utils.CoverArt
+import audio.funkwhale.ffa.utils.Event
+import audio.funkwhale.ffa.utils.EventBus
+import audio.funkwhale.ffa.utils.Request
+import audio.funkwhale.ffa.utils.RequestBus
+import audio.funkwhale.ffa.utils.Response
+import audio.funkwhale.ffa.utils.getMetadata
+import audio.funkwhale.ffa.utils.maybeNormalizeUrl
+import audio.funkwhale.ffa.utils.toast
+import audio.funkwhale.ffa.utils.wait
 import com.google.android.exoplayer2.offline.Download
 import com.google.android.exoplayer2.offline.DownloadManager
 import com.preference.PowerPreference
-import com.squareup.picasso.Picasso
 import jp.wasabeef.picasso.transformations.RoundedCornersTransformation
 import kotlinx.coroutines.Dispatchers.IO
 import kotlinx.coroutines.Dispatchers.Main
-import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import org.koin.java.KoinJavaComponent.inject
 
 class TracksFragment : FFAFragment<Track, TracksAdapter>() {
-
+  private val args by navArgs<TracksFragmentArgs>()
   private val exoDownloadManager: DownloadManager by inject(DownloadManager::class.java)
 
   override val recycler: RecyclerView get() = binding.tracks
@@ -44,38 +53,14 @@ class TracksFragment : FFAFragment<Track, TracksAdapter>() {
   private lateinit var favoritesRepository: FavoritesRepository
   private lateinit var favoritedRepository: FavoritedRepository
 
-  private var albumId = 0
-  private var albumArtist = ""
-  private var albumTitle = ""
-  private var albumCover = ""
-
-  companion object {
-    fun new(album: Album): TracksFragment {
-      return TracksFragment().apply {
-        arguments = bundleOf(
-          "albumId" to album.id,
-          "albumArtist" to album.artist.name,
-          "albumTitle" to album.title,
-          "albumCover" to album.cover()
-        )
-      }
-    }
-  }
-
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
 
-    arguments?.apply {
-      albumId = getInt("albumId")
-      albumArtist = getString("albumArtist") ?: ""
-      albumTitle = getString("albumTitle") ?: ""
-      albumCover = getString("albumCover") ?: ""
-    }
-
-    adapter = TracksAdapter(layoutInflater, context, FavoriteListener())
-    repository = TracksRepository(context, albumId)
     favoritesRepository = FavoritesRepository(context)
     favoritedRepository = FavoritedRepository(context)
+    repository = TracksRepository(context, args.album.id)
+
+    adapter = TracksAdapter(layoutInflater, context, FavoriteListener(favoritesRepository))
 
     watchEventBus()
   }
@@ -116,6 +101,12 @@ class TracksFragment : FFAFragment<Track, TracksAdapter>() {
   ): View {
     _binding = FragmentTracksBinding.inflate(inflater)
     swiper = binding.swiper
+
+    when (PowerPreference.getDefaultFile().getString("play_order")) {
+      "in_order" -> binding.play.text = getString(R.string.playback_play)
+      else -> binding.play.text = getString(R.string.playback_shuffle)
+    }
+
     return binding.root
   }
 
@@ -127,16 +118,15 @@ class TracksFragment : FFAFragment<Track, TracksAdapter>() {
   override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
     super.onViewCreated(view, savedInstanceState)
 
-    Picasso.get()
-      .maybeLoad(maybeNormalizeUrl(albumCover))
+    CoverArt.requestCreator(maybeNormalizeUrl(args.album.cover()))
       .noFade()
       .fit()
       .centerCrop()
       .transform(RoundedCornersTransformation(16, 0))
       .into(binding.cover)
 
-    binding.artist.text = albumArtist
-    binding.title.text = albumTitle
+    binding.artist.text = args.album.artist.name
+    binding.title.text = args.album.title
   }
 
   override fun onResume() {
@@ -175,7 +165,6 @@ class TracksFragment : FFAFragment<Track, TracksAdapter>() {
         "in_order" -> CommandBus.send(Command.ReplaceQueue(adapter.data))
         else -> CommandBus.send(Command.ReplaceQueue(adapter.data.shuffled()))
       }
-
       context.toast("All tracks were added to your queue")
     }
 
@@ -199,8 +188,10 @@ class TracksFragment : FFAFragment<Track, TracksAdapter>() {
 
           setOnMenuItemClickListener {
             when (it.itemId) {
-              R.id.play_secondary -> when (PowerPreference.getDefaultFile()
-                .getString("play_order")) {
+              R.id.play_secondary -> when (
+                PowerPreference.getDefaultFile()
+                  .getString("play_order")
+              ) {
                 "in_order" -> CommandBus.send(Command.ReplaceQueue(adapter.data.shuffled()))
                 else -> CommandBus.send(Command.ReplaceQueue(adapter.data))
               }
@@ -229,16 +220,16 @@ class TracksFragment : FFAFragment<Track, TracksAdapter>() {
   private fun watchEventBus() {
     lifecycleScope.launch(IO) {
       EventBus.get().collect { message ->
-        when (message) {
-          is Event.DownloadChanged -> refreshDownloadedTrack(message.download)
+        if (message is Event.DownloadChanged) {
+          refreshDownloadedTrack(message.download)
         }
       }
     }
 
     lifecycleScope.launch(Main) {
       CommandBus.get().collect { command ->
-        when (command) {
-          is Command.RefreshTrack -> refreshCurrentTrack(command.track)
+        if (command is Command.RefreshTrack) {
+          refreshCurrentTrack(command.track)
         }
       }
     }
@@ -248,10 +239,12 @@ class TracksFragment : FFAFragment<Track, TracksAdapter>() {
     val downloaded = TracksRepository.getDownloadedIds(exoDownloadManager) ?: listOf()
 
     withContext(Main) {
-      adapter.data = adapter.data.map {
+      adapter.setUnfilteredData(
+        adapter.data.map {
           it.downloaded = downloaded.contains(it.id)
           it
         }.toMutableList()
+      )
 
       adapter.notifyDataSetChanged()
     }
@@ -281,13 +274,4 @@ class TracksFragment : FFAFragment<Track, TracksAdapter>() {
       adapter.notifyDataSetChanged()
     }
   }
-
-  inner class FavoriteListener : TracksAdapter.OnFavoriteListener {
-    override fun onToggleFavorite(id: Int, state: Boolean) {
-      when (state) {
-        true -> favoritesRepository.addFavorite(id)
-        false -> favoritesRepository.deleteFavorite(id)
-      }
-    }
-  }
 }

app/src/main/java/audio/funkwhale/ffa/koin/Modules.kt

@@ -6,7 +6,7 @@ import audio.funkwhale.ffa.playback.MediaSession
 import audio.funkwhale.ffa.utils.AuthorizationServiceFactory
 import audio.funkwhale.ffa.utils.OAuth
 import com.google.android.exoplayer2.database.DatabaseProvider
-import com.google.android.exoplayer2.database.ExoDatabaseProvider
+import com.google.android.exoplayer2.database.StandaloneDatabaseProvider
 import com.google.android.exoplayer2.offline.DownloadManager
 import com.google.android.exoplayer2.upstream.cache.Cache
 import com.google.android.exoplayer2.upstream.cache.LeastRecentlyUsedCacheEvictor
@@ -19,7 +19,7 @@ import org.koin.dsl.module
 fun exoplayerModule(context: Context) = module {
 
   single<DatabaseProvider>(named("exoDatabase")) {
-    ExoDatabaseProvider(context)
+    StandaloneDatabaseProvider(context)
   }
 
   single {

app/src/main/java/audio/funkwhale/ffa/model/Album.kt

 package audio.funkwhale.ffa.model
 
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
 data class Album(
   val id: Int,
   val artist: Artist,
   val title: String,
-  val cover: Covers?,
+  private val cover: Covers?,
   val release_date: String?
-) : SearchResult {
-  data class Artist(val name: String)
+) : SearchResult, Parcelable {
+  @Parcelize
+  data class Artist(val name: String) : Parcelable
 
   override fun cover() = cover?.urls?.original
   override fun title() = title

app/src/main/java/audio/funkwhale/ffa/model/Artist.kt

 package audio.funkwhale.ffa.model
 
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+import java.util.Calendar.DAY_OF_YEAR
+import java.util.GregorianCalendar
+
+@Parcelize
 data class Artist(
   val id: Int,
   val name: String,
   val albums: List<Album>?
-) : SearchResult {
+) : SearchResult, Parcelable {
+  @Parcelize
   data class Album(
     val title: String,
     val cover: Covers?
-  )
+  ) : Parcelable
+
+  override fun cover(): String? = albums?.mapNotNull { it.cover?.urls?.original }?.let { covers ->
+    if (covers.isEmpty()) {
+      return@let null
+    }
+    // Inject a little whimsy: rotate through the album covers daily
+    val index = GregorianCalendar().get(DAY_OF_YEAR) % covers.size
+    covers.getOrNull(index)
+  }
 
-  override fun cover(): String? = albums?.getOrNull(0)?.cover?.urls?.original
   override fun title() = name
   override fun subtitle() = "Artist"
 }

app/src/main/java/audio/funkwhale/ffa/model/CacheItem.kt

@@ -5,6 +5,7 @@ sealed class CacheItem<D : Any>(val data: List<D>)
 class ArtistsCache(data: List<Artist>) : CacheItem<Artist>(data)
 class AlbumsCache(data: List<Album>) : CacheItem<Album>(data)
 class TracksCache(data: List<Track>) : CacheItem<Track>(data)
+class FavoritesCache(data: List<Favorite>) : CacheItem<Favorite>(data)
 class PlaylistsCache(data: List<Playlist>) : CacheItem<Playlist>(data)
 class PlaylistTracksCache(data: List<PlaylistTrack>) : CacheItem<PlaylistTrack>(data)
 class RadiosCache(data: List<Radio>) : CacheItem<Radio>(data)

app/src/main/java/audio/funkwhale/ffa/model/CoverUrls.kt

 package audio.funkwhale.ffa.model
 
-data class CoverUrls(val original: String)
+import android.os.Parcelable
\ No newline at end of file
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
+data class CoverUrls(val original: String) : Parcelable

app/src/main/java/audio/funkwhale/ffa/model/Covers.kt

 package audio.funkwhale.ffa.model
 
-data class Covers(val urls: CoverUrls)
+import android.os.Parcelable
\ No newline at end of file
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
+data class Covers(val urls: CoverUrls) : Parcelable

app/src/main/java/audio/funkwhale/ffa/model/Favorite.kt

+package audio.funkwhale.ffa.model
+
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
+data class Favorite(
+  val id: Int = 0,
+  val track: Track
+) : Parcelable

app/src/main/java/audio/funkwhale/ffa/model/FavoritesResponse.kt

+package audio.funkwhale.ffa.model
+
+data class FavoritesResponse(
+  override val count: Int,
+  override val next: String?,
+  val results: List<Favorite>
+) : FFAResponse<Favorite>() {
+  override fun getData() = results
+}

app/src/main/java/audio/funkwhale/ffa/model/Playlist.kt

 package audio.funkwhale.ffa.model
 
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+
+@Parcelize
 data class Playlist(
   val id: Int,
   val name: String,
   val album_covers: List<String>,
   val tracks_count: Int,
   val duration: Int
-)
+) : Parcelable
\ No newline at end of file