WIP artist

app/src/main/java/code/name/monkey/retromusic/activities/AlbumDetailsActivity.kt

@@ -29,7 +29,6 @@ import code.name.monkey.retromusic.dialogs.DeleteSongsDialog
 import code.name.monkey.retromusic.extensions.show
 import code.name.monkey.retromusic.glide.ArtistGlideRequest
 import code.name.monkey.retromusic.glide.RetroMusicColoredTarget
-import code.name.monkey.retromusic.glide.SongGlideRequest
 import code.name.monkey.retromusic.helper.MusicPlayerRemote
 import code.name.monkey.retromusic.helper.SortOrder.AlbumSongSortOrder
 import code.name.monkey.retromusic.misc.AppBarStateChangeListener
@@ -37,8 +36,6 @@ import code.name.monkey.retromusic.model.Album
 import code.name.monkey.retromusic.model.Artist
 import code.name.monkey.retromusic.mvp.presenter.AlbumDetailsPresenter
 import code.name.monkey.retromusic.mvp.presenter.AlbumDetailsView
-import code.name.monkey.retromusic.util.MusicUtil
-import code.name.monkey.retromusic.util.NavigationUtil
 import code.name.monkey.retromusic.util.PreferenceUtil
 import code.name.monkey.retromusic.util.RetroUtil
 import com.bumptech.glide.Glide
@@ -51,6 +48,9 @@ import javax.inject.Inject
 import android.util.Pair as UtilPair
 
 class AlbumDetailsActivity : AbsSlidingMusicPanelActivity(), AlbumDetailsView {
+    override fun showEmptyView() {
+
+    }
 
     private lateinit var simpleSongAdapter: SimpleSongAdapter
     private var disposable = CompositeDisposable()
@@ -93,20 +93,20 @@ class AlbumDetailsActivity : AbsSlidingMusicPanelActivity(), AlbumDetailsView {
 
         artistImage.setOnClickListener {
             val artistPairs = ActivityOptions.makeSceneTransitionAnimation(this, UtilPair.create(artistImage, getString(R.string.transition_artist_image)))
-            NavigationUtil.goToArtistOptions(this, album.artistId, artistPairs)
+            //NavigationUtil.goToArtistOptions(this, album.artistId, artistPairs)
         }
         playAction.apply {
-            setOnClickListener { MusicPlayerRemote.openQueue(album.songs!!, 0, true) }
+            //setOnClickListener { MusicPlayerRemote.openQueue(album.songs!!, 0, true) }
         }
         shuffleAction.apply {
-            setOnClickListener { MusicPlayerRemote.openAndShuffleQueue(album.songs!!, true) }
+            //setOnClickListener { MusicPlayerRemote.openAndShuffleQueue(album.songs!!, true) }
         }
 
 
         albumDetailsPresenter.attachView(this)
 
         if (intent.extras!!.containsKey(EXTRA_ALBUM_ID)) {
-            intent.extras?.getInt(EXTRA_ALBUM_ID)?.let { albumDetailsPresenter.loadAlbum(it) }
+            intent.extras?.getLong(EXTRA_ALBUM_ID)?.let { albumDetailsPresenter.loadAlbum(it) }
         } else {
             finish()
         }
@@ -171,18 +171,18 @@ class AlbumDetailsActivity : AbsSlidingMusicPanelActivity(), AlbumDetailsView {
 
     override fun album(album: Album) {
 
-        if (album.songs!!.isEmpty()) {
+        /*if (album.songs!!.isEmpty()) {
             finish()
             return
-        }
+        }*/
         this.album = album
 
         albumTitle.text = album.title
-        albumText.text = String.format("%s • %s • %s", album.artistName, MusicUtil.getYearString(album.year), MusicUtil.getReadableDurationString(MusicUtil.getTotalDuration(this, album.songs)))
+        //albumText.text = String.format("%s • %s • %s", album.artistName, MusicUtil.getYearString(album.year), MusicUtil.getReadableDurationString(MusicUtil.getTotalDuration(this, album.songs)))
 
         loadAlbumCover()
-        simpleSongAdapter.swapDataSet(album.songs)
+        //simpleSongAdapter.swapDataSet(album.songs)
-        albumDetailsPresenter.loadMore(album.artistId)
+        //albumDetailsPresenter.loadMore(album.artistId)
     }
 
     private lateinit var artistImage: ImageView
@@ -210,7 +210,7 @@ class AlbumDetailsActivity : AbsSlidingMusicPanelActivity(), AlbumDetailsView {
     }
 
     private fun loadAlbumCover() {
-        SongGlideRequest.Builder.from(Glide.with(this), album.safeGetFirstSong())
+        /*SongGlideRequest.Builder.from(Glide.with(this), album.safeGetFirstSong())
                 .checkIgnoreMediaStore(this)
                 .generatePalette(this).build()
                 .dontAnimate()
@@ -218,7 +218,7 @@ class AlbumDetailsActivity : AbsSlidingMusicPanelActivity(), AlbumDetailsView {
                     override fun onColorReady(color: Int) {
                         setColors(color)
                     }
-                })
+                })*/
     }
 
     private fun scheduleStartPostponedTransition(image: ImageView) {
@@ -323,7 +323,7 @@ class AlbumDetailsActivity : AbsSlidingMusicPanelActivity(), AlbumDetailsView {
 
     private fun reload() {
         if (intent.extras!!.containsKey(EXTRA_ALBUM_ID)) {
-            intent.extras?.getInt(EXTRA_ALBUM_ID)?.let { albumDetailsPresenter.loadAlbum(it) }
+            intent.extras?.getLong(EXTRA_ALBUM_ID)?.let { albumDetailsPresenter.loadAlbum(it) }
         } else {
             finish()
         }

app/src/main/java/code/name/monkey/retromusic/activities/ArtistDetailActivity.kt

@@ -32,7 +32,9 @@ import code.name.monkey.retromusic.glide.ArtistGlideRequest
 import code.name.monkey.retromusic.glide.RetroMusicColoredTarget
 import code.name.monkey.retromusic.helper.MusicPlayerRemote
 import code.name.monkey.retromusic.misc.AppBarStateChangeListener
+import code.name.monkey.retromusic.model.Album
 import code.name.monkey.retromusic.model.Artist
+import code.name.monkey.retromusic.model.Song
 import code.name.monkey.retromusic.mvp.presenter.ArtistDetailsPresenter
 import code.name.monkey.retromusic.mvp.presenter.ArtistDetailsView
 import code.name.monkey.retromusic.rest.LastFMRestClient
@@ -48,6 +50,7 @@ import kotlin.collections.ArrayList
 
 class ArtistDetailActivity : AbsSlidingMusicPanelActivity(), ArtistDetailsView {
 
+
     private var biography: Spanned? = null
     private lateinit var artist: Artist
     private var lastFMRestClient: LastFMRestClient? = null
@@ -84,10 +87,10 @@ class ArtistDetailActivity : AbsSlidingMusicPanelActivity(), ArtistDetailsView {
         setUpViews()
 
         playAction.apply {
-            setOnClickListener { MusicPlayerRemote.openQueue(artist.songs, 0, true) }
+            //setOnClickListener { MusicPlayerRemote.openQueue(artist.songs, 0, true) }
         }
         shuffleAction.apply {
-            setOnClickListener { MusicPlayerRemote.openAndShuffleQueue(artist.songs, true) }
+            //setOnClickListener { MusicPlayerRemote.openAndShuffleQueue(artist.songs, true) }
         }
 
         biographyText.setOnClickListener {
@@ -102,7 +105,7 @@ class ArtistDetailActivity : AbsSlidingMusicPanelActivity(), ArtistDetailsView {
         artistDetailsPresenter.attachView(this)
 
         if (intent.extras!!.containsKey(EXTRA_ARTIST_ID)) {
-            intent.extras?.getInt(EXTRA_ARTIST_ID)?.let { artistDetailsPresenter.loadArtist(it) }
+            intent.extras?.getLong(EXTRA_ARTIST_ID)?.let { artistDetailsPresenter.loadArtist(it) }
         } else {
             finish()
         }
@@ -211,11 +214,19 @@ class ArtistDetailActivity : AbsSlidingMusicPanelActivity(), ArtistDetailsView {
             loadBiography(artist.name)
         }
         artistTitle.text = artist.name
-        text.text = String.format("%s • %s", MusicUtil.getArtistInfoString(this, artist), MusicUtil
+        text.text = String.format("%s", MusicUtil.getArtistInfoString(this, artist))
-                .getReadableDurationString(MusicUtil.getTotalDuration(this, artist.songs)))
 
-        songAdapter.swapDataSet(artist.songs)
+        artistDetailsPresenter.loadArtistSongs(artist.id)
-        albumAdapter.swapDataSet(artist.albums!!)
+        artistDetailsPresenter.loadArtistAlbums(artist.id)
+
+    }
+
+    override fun artistSong(songs: ArrayList<Song>) {
+        songAdapter.swapDataSet(songs)
+    }
+
+    override fun artistAlbums(albums: ArrayList<Album>) {
+        albumAdapter.swapDataSet(albums)
     }
 
     private fun loadBiography(name: String,
@@ -280,7 +291,7 @@ class ArtistDetailActivity : AbsSlidingMusicPanelActivity(), ArtistDetailsView {
     }
 
     private fun handleSortOrderMenuItem(item: MenuItem): Boolean {
-        val songs = artist.songs
+        val songs = ArrayList<Song>()
         when (item.itemId) {
             android.R.id.home -> {
                 super.onBackPressed()
@@ -327,7 +338,7 @@ class ArtistDetailActivity : AbsSlidingMusicPanelActivity(), ArtistDetailsView {
 
     private fun reload() {
         if (intent.extras!!.containsKey(EXTRA_ARTIST_ID)) {
-            intent.extras?.getInt(EXTRA_ARTIST_ID)?.let { artistDetailsPresenter.loadArtist(it) }
+            intent.extras?.getLong(EXTRA_ARTIST_ID)?.let { artistDetailsPresenter.loadArtist(it) }
         } else {
             finish()
         }

app/src/main/java/code/name/monkey/retromusic/activities/MainActivity.kt

@@ -15,8 +15,6 @@ import code.name.monkey.retromusic.fragments.mainactivity.home.BannerHomeFragmen
 import code.name.monkey.retromusic.helper.MusicPlayerRemote
 import code.name.monkey.retromusic.helper.SearchQueryHelper
 import code.name.monkey.retromusic.interfaces.MainActivityFragmentCallbacks
-import code.name.monkey.retromusic.loaders.AlbumLoader
-import code.name.monkey.retromusic.loaders.ArtistLoader
 import code.name.monkey.retromusic.loaders.PlaylistSongsLoader
 import code.name.monkey.retromusic.service.MusicService
 import code.name.monkey.retromusic.util.AppRater
@@ -154,14 +152,14 @@ class MainActivity : AbsSlidingMusicPanelActivity(), SharedPreferences.OnSharedP
             val id = parseIdFromIntent(intent, "albumId", "album").toInt()
             if (id >= 0) {
                 val position = intent.getIntExtra("position", 0)
-                MusicPlayerRemote.openQueue(AlbumLoader.getAlbum(this, id).songs!!, position, true)
+                //MusicPlayerRemote.openQueue(AlbumLoader.getAlbum(this, id).songs!!, position, true)
                 handled = true
             }
         } else if (MediaStore.Audio.Artists.CONTENT_TYPE == mimeType) {
             val id = parseIdFromIntent(intent, "artistId", "artist").toInt()
             if (id >= 0) {
                 val position = intent.getIntExtra("position", 0)
-                MusicPlayerRemote.openQueue(ArtistLoader.getArtist(this, id).songs, position, true)
+                //MusicPlayerRemote.openQueue(ArtistLoader.getArtist(this, id).songs, position, true)
                 handled = true
             }
         }

app/src/main/java/code/name/monkey/retromusic/activities/tageditor/AlbumTagEditorActivity.kt

@@ -20,7 +20,7 @@ import code.name.monkey.retromusic.R
 import code.name.monkey.retromusic.extensions.appHandleColor
 import code.name.monkey.retromusic.glide.palette.BitmapPaletteTranscoder
 import code.name.monkey.retromusic.glide.palette.BitmapPaletteWrapper
-import code.name.monkey.retromusic.loaders.AlbumLoader
+import code.name.monkey.retromusic.model.Song
 import code.name.monkey.retromusic.rest.LastFMRestClient
 import code.name.monkey.retromusic.rest.model.LastFmAlbum
 import code.name.monkey.retromusic.util.ImageUtil
@@ -38,6 +38,7 @@ import io.reactivex.schedulers.Schedulers
 import kotlinx.android.synthetic.main.activity_album_tag_editor.*
 import org.jaudiotagger.tag.FieldKey
 import java.util.*
+import kotlin.collections.ArrayList
 
 
 class AlbumTagEditorActivity : AbsTagEditorActivity(), TextWatcher {
@@ -228,7 +229,7 @@ class AlbumTagEditorActivity : AbsTagEditorActivity(), TextWatcher {
     }
 
     override fun getSongPaths(): List<String> {
-        val songs = AlbumLoader.getAlbum(this, id).songs
+        val songs = ArrayList<Song>()//AlbumLoader.getAlbum(this, id).songs
         val paths = ArrayList<String>(songs!!.size)
         for (song in songs) {
             paths.add(song.data)

app/src/main/java/code/name/monkey/retromusic/adapter/SearchAdapter.kt

@@ -10,14 +10,12 @@ import code.name.monkey.appthemehelper.ThemeStore
 import code.name.monkey.retromusic.R
 import code.name.monkey.retromusic.adapter.base.MediaEntryViewHolder
 import code.name.monkey.retromusic.glide.ArtistGlideRequest
-import code.name.monkey.retromusic.glide.SongGlideRequest
 import code.name.monkey.retromusic.helper.MusicPlayerRemote
 import code.name.monkey.retromusic.helper.menu.SongMenuHelper
 import code.name.monkey.retromusic.model.Album
 import code.name.monkey.retromusic.model.Artist
 import code.name.monkey.retromusic.model.Song
 import code.name.monkey.retromusic.util.MusicUtil
-import code.name.monkey.retromusic.util.NavigationUtil
 import com.bumptech.glide.Glide
 import android.util.Pair as UtilPair
 
@@ -47,9 +45,9 @@ class SearchAdapter(
                 val album = dataSet?.get(position) as Album
                 holder.title?.text = album.title
                 holder.text?.text = album.artistName
-                SongGlideRequest.Builder.from(Glide.with(activity), album.safeGetFirstSong())
+                /*SongGlideRequest.Builder.from(Glide.with(activity), album.safeGetFirstSong())
                         .checkIgnoreMediaStore(activity).build()
-                        .into(holder.image)
+                        .into(holder.image)*/
             }
             ARTIST -> {
                 val artist = dataSet?.get(position) as Artist
@@ -106,12 +104,12 @@ class SearchAdapter(
                 ALBUM -> {
                     val options = ActivityOptions.makeSceneTransitionAnimation(activity,
                             UtilPair.create(image, activity.getString(R.string.transition_album_art)))
-                    NavigationUtil.goToAlbumOptions(activity, (item as Album).id, options)
+                    //NavigationUtil.goToAlbumOptions(activity, (item as Album).id, options)
                 }
                 ARTIST -> {
                     val options = ActivityOptions.makeSceneTransitionAnimation(activity,
                             UtilPair.create(image, activity.getString(R.string.transition_artist_image)))
-                    NavigationUtil.goToArtistOptions(activity, (item as Artist).id, options)
+                    //NavigationUtil.goToArtistOptions(activity, (item as Artist).id, options)
                 }
                 SONG -> {
                     val playList = ArrayList<Song>()

app/src/main/java/code/name/monkey/retromusic/adapter/album/AlbumAdapter.kt

@@ -2,7 +2,6 @@ package code.name.monkey.retromusic.adapter.album
 
 import android.app.ActivityOptions
 import android.content.res.ColorStateList
-import android.graphics.drawable.Drawable
 import android.view.LayoutInflater
 import android.view.MenuItem
 import android.view.View
@@ -14,18 +13,13 @@ import code.name.monkey.appthemehelper.util.MaterialValueHelper
 import code.name.monkey.retromusic.R
 import code.name.monkey.retromusic.adapter.base.AbsMultiSelectAdapter
 import code.name.monkey.retromusic.adapter.base.MediaEntryViewHolder
-import code.name.monkey.retromusic.glide.RetroMusicColoredTarget
-import code.name.monkey.retromusic.glide.SongGlideRequest
-import code.name.monkey.retromusic.helper.MusicPlayerRemote
 import code.name.monkey.retromusic.helper.SortOrder
 import code.name.monkey.retromusic.helper.menu.SongsMenuHelper
 import code.name.monkey.retromusic.interfaces.CabHolder
 import code.name.monkey.retromusic.model.Album
 import code.name.monkey.retromusic.model.Song
 import code.name.monkey.retromusic.util.MusicUtil
-import code.name.monkey.retromusic.util.NavigationUtil
 import code.name.monkey.retromusic.util.PreferenceUtil
-import com.bumptech.glide.Glide
 import com.simplecityapps.recyclerview_fastscroll.views.FastScrollRecyclerView
 
 
@@ -91,7 +85,7 @@ open class AlbumAdapter(protected val activity: AppCompatActivity,
             holder.text!!.text = getAlbumText(album)
         }
         if (holder.playSongs != null) {
-            holder.playSongs!!.setOnClickListener { MusicPlayerRemote.openQueue(album.songs!!, 0, true) }
+            //holder.playSongs!!.setOnClickListener { MusicPlayerRemote.openQueue(album.songs!!, 0, true) }
         }
         loadAlbumCover(album, holder)
     }
@@ -112,7 +106,7 @@ open class AlbumAdapter(protected val activity: AppCompatActivity,
             return
         }
 
-        SongGlideRequest.Builder.from(Glide.with(activity), album.safeGetFirstSong())
+        /*SongGlideRequest.Builder.from(Glide.with(activity), album.safeGetFirstSong())
                 .checkIgnoreMediaStore(activity)
                 .generatePalette(activity).build()
                 .into(object : RetroMusicColoredTarget(holder.image!!) {
@@ -124,7 +118,7 @@ open class AlbumAdapter(protected val activity: AppCompatActivity,
                     override fun onColorReady(color: Int) {
                         setColors(color, holder)
                     }
-                })
+                })*/
     }
 
     override fun getItemCount(): Int {
@@ -151,7 +145,7 @@ open class AlbumAdapter(protected val activity: AppCompatActivity,
     private fun getSongList(albums: List<Album>): ArrayList<Song> {
         val songs = ArrayList<Song>()
         for (album in albums) {
-            songs.addAll(album.songs!!)
+            //songs.addAll(album.songs!!)
         }
         return songs
     }
@@ -182,7 +176,7 @@ open class AlbumAdapter(protected val activity: AppCompatActivity,
                 toggleChecked(adapterPosition)
             } else {
                 val activityOptions = ActivityOptions.makeSceneTransitionAnimation(activity, image, activity.getString(R.string.transition_album_art))
-                NavigationUtil.goToAlbumOptions(activity, dataSet[adapterPosition].id, activityOptions)
+                //NavigationUtil.goToAlbumOptions(activity, dataSet[adapterPosition].id, activityOptions)
             }
         }
 

app/src/main/java/code/name/monkey/retromusic/adapter/album/AlbumFullWidthAdapter.kt

@@ -22,13 +22,8 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import code.name.monkey.retromusic.R
-import code.name.monkey.retromusic.glide.RetroMusicColoredTarget
-import code.name.monkey.retromusic.glide.SongGlideRequest
-import code.name.monkey.retromusic.helper.MusicPlayerRemote
 import code.name.monkey.retromusic.model.Album
-import code.name.monkey.retromusic.util.NavigationUtil
 import code.name.monkey.retromusic.views.MetalRecyclerViewPager
-import com.bumptech.glide.Glide
 
 class AlbumFullWidthAdapter(private val activity: Activity, private val dataSet: ArrayList<Album>, metrics: DisplayMetrics) :
         MetalRecyclerViewPager.MetalAdapter<AlbumFullWidthAdapter.FullMetalViewHolder>(metrics) {
@@ -50,7 +45,7 @@ class AlbumFullWidthAdapter(private val activity: Activity, private val dataSet:
             holder.text!!.text = getAlbumText(album)
         }
         if (holder.playSongs != null) {
-            holder.playSongs!!.setOnClickListener { MusicPlayerRemote.openQueue(album.songs!!, 0, true) }
+            //holder.playSongs!!.setOnClickListener { MusicPlayerRemote.openQueue(album.songs!!, 0, true) }
         }
         loadAlbumCover(album, holder)
     }
@@ -67,14 +62,14 @@ class AlbumFullWidthAdapter(private val activity: Activity, private val dataSet:
         if (holder.image == null) {
             return
         }
-        SongGlideRequest.Builder.from(Glide.with(activity), album.safeGetFirstSong())
+        /*SongGlideRequest.Builder.from(Glide.with(activity), album.safeGetFirstSong())
                 .checkIgnoreMediaStore(activity)
                 .generatePalette(activity).build()
                 .into(object : RetroMusicColoredTarget(holder.image!!) {
                     override fun onColorReady(color: Int) {
 
                     }
-                })
+                })*/
     }
 
     override fun getItemCount(): Int {
@@ -85,7 +80,7 @@ class AlbumFullWidthAdapter(private val activity: Activity, private val dataSet:
 
         override fun onClick(v: View?) {
             val activityOptions = ActivityOptions.makeSceneTransitionAnimation(activity, image, activity.getString(R.string.transition_album_art))
-            NavigationUtil.goToAlbumOptions(activity, dataSet[adapterPosition].id, activityOptions)
+            //NavigationUtil.goToAlbumOptions(activity, dataSet[adapterPosition].id, activityOptions)
         }
     }
 }

app/src/main/java/code/name/monkey/retromusic/adapter/album/HorizontalAlbumAdapter.kt

@@ -1,18 +1,14 @@
 package code.name.monkey.retromusic.adapter.album
 
-import android.graphics.drawable.Drawable
 import android.view.View
 import android.view.ViewGroup
 import androidx.appcompat.app.AppCompatActivity
 import code.name.monkey.appthemehelper.util.ColorUtil
 import code.name.monkey.appthemehelper.util.MaterialValueHelper
-import code.name.monkey.retromusic.glide.RetroMusicColoredTarget
-import code.name.monkey.retromusic.glide.SongGlideRequest
 import code.name.monkey.retromusic.helper.HorizontalAdapterHelper
 import code.name.monkey.retromusic.interfaces.CabHolder
 import code.name.monkey.retromusic.model.Album
 import code.name.monkey.retromusic.util.MusicUtil
-import com.bumptech.glide.Glide
 import java.util.*
 
 
@@ -43,7 +39,7 @@ class HorizontalAlbumAdapter(
     override fun loadAlbumCover(album: Album, holder: ViewHolder) {
         if (holder.image == null) return
 
-        SongGlideRequest.Builder.from(Glide.with(activity), album.safeGetFirstSong())
+        /*SongGlideRequest.Builder.from(Glide.with(activity), album.safeGetFirstSong())
                 .checkIgnoreMediaStore(activity)
                 .generatePalette(activity).build()
                 .into(object : RetroMusicColoredTarget(holder.image!!) {
@@ -58,7 +54,7 @@ class HorizontalAlbumAdapter(
                         else
                             setColors(albumArtistFooterColor, holder)
                     }
-                })
+                })*/
     }
 
     override fun getAlbumText(album: Album): String? {

app/src/main/java/code/name/monkey/retromusic/adapter/artist/ArtistAdapter.kt

@@ -113,7 +113,7 @@ class ArtistAdapter(val activity: AppCompatActivity,
     private fun getSongList(artists: List<Artist>): ArrayList<Song> {
         val songs = ArrayList<Song>()
         for (artist in artists) {
-            songs.addAll(artist.songs) // maybe async in future?
+            //songs.addAll(artist.songs) // maybe async in future?
         }
         return songs
     }

app/src/main/java/code/name/monkey/retromusic/fragments/player/full/FullPlayerFragment.kt

@@ -14,19 +14,13 @@ import code.name.monkey.retromusic.extensions.hide
 import code.name.monkey.retromusic.extensions.show
 import code.name.monkey.retromusic.fragments.base.AbsPlayerFragment
 import code.name.monkey.retromusic.fragments.player.PlayerAlbumCoverFragment
-import code.name.monkey.retromusic.glide.ArtistGlideRequest
-import code.name.monkey.retromusic.glide.RetroMusicColoredTarget
 import code.name.monkey.retromusic.helper.MusicPlayerRemote
 import code.name.monkey.retromusic.helper.MusicProgressViewUpdateHelper
-import code.name.monkey.retromusic.loaders.ArtistLoader
 import code.name.monkey.retromusic.model.Song
 import code.name.monkey.retromusic.model.lyrics.AbsSynchronizedLyrics
 import code.name.monkey.retromusic.model.lyrics.Lyrics
 import code.name.monkey.retromusic.util.NavigationUtil
-import com.bumptech.glide.Glide
-import io.reactivex.android.schedulers.AndroidSchedulers
 import io.reactivex.disposables.CompositeDisposable
-import io.reactivex.schedulers.Schedulers
 import kotlinx.android.synthetic.main.fragment_full.*
 
 class FullPlayerFragment : AbsPlayerFragment(), MusicProgressViewUpdateHelper.Callback {
@@ -213,7 +207,7 @@ class FullPlayerFragment : AbsPlayerFragment(), MusicProgressViewUpdateHelper.Ca
     private val compositeDisposable = CompositeDisposable()
 
     private fun updateArtistImage() {
-        compositeDisposable.addAll(ArtistLoader.getArtistFlowable(context!!, MusicPlayerRemote.currentSong.artistId)
+        /*compositeDisposable.addAll(ArtistLoader.getArtistFlowable(context!!, MusicPlayerRemote.currentSong.artistId)
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
                 .subscribe {
@@ -224,7 +218,7 @@ class FullPlayerFragment : AbsPlayerFragment(), MusicProgressViewUpdateHelper.Ca
 
                                 }
                             })
-                })
+                })*/
     }
 
     override fun onQueueChanged() {

app/src/main/java/code/name/monkey/retromusic/glide/audiocover/AudioFileCoverUtils.java

@@ -44,10 +44,7 @@ public class AudioFileCoverUtils {
                 }
             }
             // If there are any exceptions, we ignore them and continue to the other fallback method
-        } catch (ReadOnlyFileException ignored) {
+        } catch (ReadOnlyFileException | InvalidAudioFrameException | TagException | IOException ignored) {
-        } catch (InvalidAudioFrameException ignored) {
-        } catch (TagException ignored) {
-        } catch (IOException ignored) {
         }
 
         // Method 2: look for album art in external files

app/src/main/java/code/name/monkey/retromusic/loaders/AlbumLoader.kt

@@ -15,13 +15,12 @@
 package code.name.monkey.retromusic.loaders
 
 import android.content.Context
-import android.provider.MediaStore.Audio.AudioColumns
+import android.database.Cursor
+import android.provider.MediaStore
+import code.name.monkey.retromusic.Constants
 import code.name.monkey.retromusic.model.Album
 import code.name.monkey.retromusic.model.Song
 import code.name.monkey.retromusic.util.PreferenceUtil
-import io.reactivex.Observable
-import java.util.*
-import kotlin.collections.ArrayList
 
 
 /**
@@ -29,7 +28,92 @@ import kotlin.collections.ArrayList
  */
 
 object AlbumLoader {
-    fun getAllAlbumsFlowable(
+
+    fun allAlbums(context: Context): ArrayList<Album> {
+        return getAlbumsForCursor(makeAlbumCursor(context, null, null))
+    }
+
+    private fun getAlbumsForCursor(cursor: Cursor?): ArrayList<Album> {
+        val arrayList = ArrayList<Album>()
+        if (cursor != null && cursor.moveToFirst()) {
+            do {
+                arrayList.add(albumCursorImpl(cursor))
+            } while (cursor.moveToNext())
+        }
+        cursor?.close()
+        return arrayList
+    }
+
+    private fun makeAlbumCursor(
+            context: Context,
+            selection: String?,
+            paramArrayOfString: Array<String>?
+    ): Cursor? {
+        val albumSortOrder = PreferenceUtil.getInstance(context).albumSortOrder
+        return context.contentResolver.query(
+                MediaStore.Audio.Albums.EXTERNAL_CONTENT_URI,
+                arrayOf("_id",
+                        MediaStore.Audio.Albums.ALBUM,
+                        MediaStore.Audio.Albums.ARTIST,
+                        MediaStore.Audio.AudioColumns.ARTIST_ID,
+                        MediaStore.Audio.Albums.NUMBER_OF_SONGS,
+                        MediaStore.Audio.Albums.FIRST_YEAR),
+                selection,
+                paramArrayOfString,
+                albumSortOrder
+        )
+    }
+
+    fun getAlbum(context: Context, id: Long): Album {
+        return getAlbum(makeAlbumCursor(context, "_id=?", arrayOf(id.toString())))
+    }
+
+    private fun getAlbum(cursor: Cursor?): Album {
+        val album = Album()
+        if (cursor != null && cursor.moveToFirst()) {
+            albumCursorImpl(cursor)
+        }
+        cursor?.close()
+        return album
+    }
+
+    private fun albumCursorImpl(cursor: Cursor): Album {
+        return Album(cursor.getLong(0),
+                cursor.getString(1),
+                cursor.getString(2),
+                cursor.getLong(3),
+                cursor.getInt(4),
+                cursor.getInt(5))
+    }
+
+    fun getAlbums(context: Context, paramString: String, limit: Int): MutableList<Album> {
+        val result = getAlbumsForCursor(makeAlbumCursor(context, "album LIKE ?", arrayOf("$paramString%")))
+        if (result.size < limit) {
+            result.addAll(getAlbumsForCursor(makeAlbumCursor(context, "album LIKE ?", arrayOf("%_$paramString%"))))
+        }
+        return if (result.size < limit) result else result.subList(0, limit)
+    }
+
+    fun getAlbumSong(context: Context, albumId: Long): ArrayList<Song> {
+        val arrayList = ArrayList<Song>()
+        val cursor = makeAlbumSongsCursor(context, albumId)
+        if (cursor != null && cursor.moveToFirst()) {
+            do {
+                arrayList.add(SongLoader.getSong(cursor))
+            } while (cursor.moveToNext())
+        }
+        cursor?.close()
+        return arrayList
+    }
+
+    private fun makeAlbumSongsCursor(context: Context, albumId: Long): Cursor? {
+        val sortOrder = PreferenceUtil.getInstance(context).albumSongSortOrder
+        val selection = "is_music=1 AND title != '' AND album_id=$albumId"
+        return context.contentResolver.query(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
+                Constants.baseProjection, selection, null, sortOrder)
+    }
+
+    /*fun getAllAlbumsFlowable(
             context: Context
     ): Observable<ArrayList<Album>> {
         val songs = SongLoader.getSongsFlowable(
@@ -81,10 +165,10 @@ object AlbumLoader {
                             getSongLoaderSortOrder(context)
                     )
             )
-            songs.subscribe { songs1 ->
+            *//*songs.subscribe { songs1 ->
                 e.onNext(Album(songs1))
                 e.onComplete()
-            }
+            }*//*
         }
     }
 
@@ -98,7 +182,7 @@ object AlbumLoader {
                         AudioColumns.ALBUM_ID + "=?",
                         arrayOf(albumId.toString()),
                         getSongLoaderSortOrder(context)))
-        val album = Album(songs)
+        val album = Album( )
         sortSongsByTrackNumber(album)
         return album
     }
@@ -111,7 +195,7 @@ object AlbumLoader {
             songs?.subscribe { songs1 ->
                 for (song in songs1) {
                     getOrCreateAlbumFlowable(albums, song.albumId).subscribe { album ->
-                        album.songs!!.add(song)
+                        //album.songs!!.add(song)
                     }
                 }
             }
@@ -192,5 +276,5 @@ object AlbumLoader {
     private fun getSongLoaderSortOrder(context: Context): String {
         return PreferenceUtil.getInstance(context).albumSortOrder + ", " +
                 PreferenceUtil.getInstance(context).albumDetailSongSortOrder
-    }
+    }*/
 }

app/src/main/java/code/name/monkey/retromusic/loaders/ArtistLoader.kt

@@ -15,11 +15,13 @@
 package code.name.monkey.retromusic.loaders
 
 import android.content.Context
-import android.provider.MediaStore.Audio.AudioColumns
+import android.database.Cursor
+import android.provider.MediaStore
+import code.name.monkey.retromusic.Constants
 import code.name.monkey.retromusic.model.Album
 import code.name.monkey.retromusic.model.Artist
+import code.name.monkey.retromusic.model.Song
 import code.name.monkey.retromusic.util.PreferenceUtil
-import io.reactivex.Observable
 
 
 object ArtistLoader {
@@ -30,30 +32,140 @@ object ArtistLoader {
                 PreferenceUtil.getInstance(context).artistDetailSongSortOrder
     }
 
-    fun getAllArtistsFlowable(
-            context: Context
-    ): Observable<ArrayList<Artist>> {
-        return Observable.create { e ->
-            SongLoader.getSongsFlowable(SongLoader.makeSongCursor(
-                    context, null, null,
-                    getSongLoaderSortOrder(context))
-            ).subscribe { songs ->
-                e.onNext(splitIntoArtists(AlbumLoader.splitIntoAlbums(songs)))
-                e.onComplete()
-            }
-        }
-    }
 
     fun getAllArtists(context: Context): ArrayList<Artist> {
-        val songs = SongLoader.getSongs(SongLoader.makeSongCursor(
+        return getArtistsForCursor(makeArtistCursor(context, null, null));
-                context,
-                null, null,
-                getSongLoaderSortOrder(context))
-        )
-        return splitIntoArtists(AlbumLoader.splitIntoAlbums(songs))
     }
 
-    fun getArtistsFlowable(context: Context, query: String): Observable<ArrayList<Artist>> {
+    private fun getArtistsForCursor(cursor: Cursor?): java.util.ArrayList<Artist> {
+        val arrayList = ArrayList<Artist>()
+        if (cursor != null && cursor.moveToFirst()) {
+            do {
+                arrayList.add(Artist(cursor.getLong(0),
+                        cursor.getString(1),
+                        cursor.getLong(2),
+                        cursor.getLong(3)))
+            } while (cursor.moveToNext())
+        }
+        cursor?.close()
+        return arrayList
+    }
+
+
+    fun getArtist(cursor: Cursor?): Artist {
+        var artist = Artist()
+        if (cursor != null) {
+            if (cursor.moveToFirst())
+                artist = Artist(cursor.getLong(0),
+                        cursor.getString(1),
+                        cursor.getLong(2),
+                        cursor.getLong(3))
+        }
+        cursor?.close()
+        return artist
+    }
+
+    fun getArtist(context: Context, id: Long): Artist {
+        return getArtist(makeArtistCursor(context, "_id=?", arrayOf(id.toString())))
+    }
+
+    fun getArtists(context: Context, paramString: String, limit: Int): List<Artist> {
+        val result = getArtistsForCursor(makeArtistCursor(context, "artist LIKE ?", arrayOf("$paramString%")))
+        if (result.size < limit) {
+            result.addAll(getArtistsForCursor(makeArtistCursor(context, "artist LIKE ?", arrayOf("%_$paramString%"))))
+        }
+        return if (result.size < limit) result else result.subList(0, limit)
+    }
+
+
+    fun artistSongs(context: Context, artistId: Long): ArrayList<Song> {
+        val arrayList = arrayListOf<Song>()
+        val cursor = makeArtistSongsCursor(context, artistId)
+        if (cursor != null && cursor.moveToFirst()) {
+            do {
+                arrayList.add(getSongFromCursorImpl(cursor))
+            } while (cursor.moveToNext())
+        }
+        cursor?.close()
+        return arrayList
+    }
+
+    private fun getSongFromCursorImpl(
+            cursor: Cursor
+    ): Song {
+        val id = cursor.getInt(0)
+        val title = cursor.getString(1)
+        val trackNumber = cursor.getInt(2)
+        val year = cursor.getInt(3)
+        val duration = cursor.getLong(4)
+        val data = cursor.getString(5)
+        val dateModified = cursor.getLong(6)
+        val albumId = cursor.getInt(7)
+        val albumName = cursor.getString(8)
+        val artistId = cursor.getInt(9)
+        val artistName = cursor.getString(10)
+        val composer = cursor.getString(11)
+
+        return Song(id, title, trackNumber, year, duration, data, dateModified, albumId,
+                albumName ?: "", artistId, artistName, composer ?: "")
+    }
+
+    fun artistAlbums(context: Context, artistId: Long): ArrayList<Album> {
+        val arrayList = ArrayList<Album>()
+        val cursor = makeArtistAlbumsCursor(context, artistId)
+        if (cursor != null && cursor.moveToFirst()) {
+            do {
+                arrayList.add(Album(
+                        cursor.getLong(0),
+                        cursor.getString(1),
+                        cursor.getString(2),
+                         artistId,
+                        cursor.getInt(3),
+                        cursor.getInt(4)))
+            } while (cursor.moveToNext())
+        }
+        cursor?.close()
+        return arrayList
+    }
+
+    private fun makeArtistAlbumsCursor(context: Context, artistId: Long): Cursor? {
+        val sortOrder = PreferenceUtil.getInstance(context).artistAlbumSortOrder
+        return context.contentResolver.query(MediaStore.Audio.Artists.Albums.getContentUri("external", artistId),
+                arrayOf("_id",
+                        MediaStore.Audio.Artists.Albums.ALBUM,
+                        MediaStore.Audio.Artists.Albums.ARTIST,
+                        MediaStore.Audio.Artists.Albums.NUMBER_OF_SONGS,
+                        MediaStore.Audio.Artists.Albums.FIRST_YEAR),
+                null,
+                null,
+                sortOrder)
+
+    }
+
+    private fun makeArtistSongsCursor(context: Context, artistId: Long): Cursor? {
+        val sortOrder = PreferenceUtil.getInstance(context).artistSongSortOrder
+        val selection = "is_music=1 AND title != '' AND artist_id=$artistId"
+        return context.contentResolver.query(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
+                Constants.baseProjection,
+                selection,
+                null,
+                sortOrder)
+    }
+
+    private fun makeArtistCursor(context: Context,
+                                 selection: String?,
+                                 selectionValues: Array<String>?
+    ): Cursor? {
+        val sortOrder = PreferenceUtil.getInstance(context).artistSortOrder
+        return context.contentResolver.query(
+                MediaStore.Audio.Artists.EXTERNAL_CONTENT_URI,
+                arrayOf("_id", "artist", "number_of_albums", "number_of_tracks"),
+                selection,
+                selectionValues,
+                sortOrder
+        )
+    }
+    /*fun getArtistsFlowable(context: Context, query: String): Observable<ArrayList<Artist>> {
         return Observable.create { e ->
             SongLoader.getSongsFlowable(SongLoader.makeSongCursor(
                     context,
@@ -134,5 +246,19 @@ object ArtistLoader {
                 getSongLoaderSortOrder(context))
         )
         return Artist(AlbumLoader.splitIntoAlbums(songs))
-    }
+    }*/
+    /*fun getAllArtistsFlowable(
+           context: Context
+   ): Observable<ArrayList<Artist>> {
+       return Observable.create { e ->
+           SongLoader.getSongsFlowable(SongLoader.makeSongCursor(
+                   context, null, null,
+                   getSongLoaderSortOrder(context))
+           ).subscribe { songs ->
+               e.onNext(splitIntoArtists(AlbumLoader.splitIntoAlbums(songs)))
+               e.onComplete()
+           }
+       }
+   }*/
+
 }

app/src/main/java/code/name/monkey/retromusic/loaders/LastAddedSongsLoader.kt

@@ -21,9 +21,6 @@ import code.name.monkey.retromusic.model.Album
 import code.name.monkey.retromusic.model.Artist
 import code.name.monkey.retromusic.model.Song
 import code.name.monkey.retromusic.util.PreferenceUtil
-import io.reactivex.Observable
-import java.util.*
-import kotlin.collections.ArrayList
 
 /**
  * Created by hemanths on 16/08/17.
@@ -31,11 +28,6 @@ import kotlin.collections.ArrayList
 
 object LastAddedSongsLoader {
 
-
-    fun getLastAddedSongsFlowable(context: Context): Observable<ArrayList<Song>> {
-        return SongLoader.getSongsFlowable(makeLastAddedCursor(context))
-    }
-
     fun getLastAddedSongs(context: Context): ArrayList<Song> {
         return SongLoader.getSongs(makeLastAddedCursor(context))
     }
@@ -51,21 +43,11 @@ object LastAddedSongsLoader {
     }
 
 
-    fun getLastAddedAlbumsFlowable(context: Context): Observable<ArrayList<Album>> {
-        return AlbumLoader.splitIntoAlbumsFlowable(getLastAddedSongsFlowable(context))
-    }
-
-
     fun getLastAddedAlbums(context: Context): ArrayList<Album> {
-        return AlbumLoader.splitIntoAlbums(getLastAddedSongs(context))
+        return arrayListOf<Album>()//AlbumLoader.splitIntoAlbums(getLastAddedSongs(context))
-    }
-
-
-    fun getLastAddedArtistsFlowable(context: Context): Observable<ArrayList<Artist>> {
-        return ArtistLoader.splitIntoArtists(getLastAddedAlbumsFlowable(context))
     }
 
     fun getLastAddedArtists(context: Context): ArrayList<Artist> {
-        return ArtistLoader.splitIntoArtists(getLastAddedAlbums(context))
+        return ArrayList()
     }
 }

app/src/main/java/code/name/monkey/retromusic/loaders/SearchLoader.kt

@@ -16,6 +16,8 @@ package code.name.monkey.retromusic.loaders
 
 import android.content.Context
 import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.model.Album
+import code.name.monkey.retromusic.model.Artist
 
 
 object SearchLoader {
@@ -28,13 +30,13 @@ object SearchLoader {
                 results.addAll(songs)
             }
 
-            val artists = ArtistLoader.getArtists(context, it)
+            val artists = ArrayList<Artist>()
             if (artists.isNotEmpty()) {
                 results.add(context.resources.getString(R.string.artists))
                 results.addAll(artists)
             }
 
-            val albums = AlbumLoader.getAlbums(context, it)
+            val albums =  arrayListOf<Album>()
             if (albums.isNotEmpty()) {
                 results.add(context.resources.getString(R.string.albums))
                 results.addAll(albums)

app/src/main/java/code/name/monkey/retromusic/loaders/SongLoader.kt

@@ -113,11 +113,10 @@ object SongLoader {
     fun getSong(
             cursor: Cursor?
     ): Song {
-        val song: Song
+        val song: Song = if (cursor != null && cursor.moveToFirst()) {
-        if (cursor != null && cursor.moveToFirst()) {
+            getSongFromCursorImpl(cursor)
-            song = getSongFromCursorImpl(cursor)
         } else {
-            song = Song.emptySong
+            Song.emptySong
         }
         cursor?.close()
         return song
@@ -140,7 +139,7 @@ object SongLoader {
     fun suggestSongs(
             context: Context
     ): Observable<ArrayList<Song>> {
-        return SongLoader.getAllSongsFlowable(context)
+        return getAllSongsFlowable(context)
                 .flatMap {
                     val list = ArrayList<Song>()
                     ShuffleHelper.makeShuffleList(it, -1)

app/src/main/java/code/name/monkey/retromusic/loaders/TopAndRecentlyPlayedTracksLoader.kt

@@ -24,7 +24,6 @@ import code.name.monkey.retromusic.model.Song
 import code.name.monkey.retromusic.providers.HistoryStore
 import code.name.monkey.retromusic.providers.SongPlayCountStore
 import io.reactivex.Observable
-import java.util.*
 
 /**
  * Created by hemanths on 16/08/17.
@@ -144,7 +143,7 @@ object TopAndRecentlyPlayedTracksLoader {
         return Observable.create { e ->
             getTopTracksFlowable(context).subscribe { songs ->
                 if (songs.size > 0) {
-                    e.onNext(AlbumLoader.splitIntoAlbums(songs))
+                    e.onNext( arrayListOf<Album>())
                 }
                 e.onComplete()
             }
@@ -154,15 +153,15 @@ object TopAndRecentlyPlayedTracksLoader {
     fun getTopAlbums(
             context: Context
     ): ArrayList<Album> {
-        arrayListOf<Album>()
+
-        return AlbumLoader.splitIntoAlbums(getTopTracks(context))
+        return  arrayListOf<Album>()
     }
 
     fun getTopArtistsFlowable(context: Context): Observable<ArrayList<Artist>> {
         return Observable.create { e ->
             getTopAlbumsFlowable(context).subscribe { albums ->
                 if (albums.size > 0) {
-                    e.onNext(ArtistLoader.splitIntoArtists(albums))
+                    e.onNext(ArrayList())
                 }
                 e.onComplete()
             }
@@ -170,6 +169,6 @@ object TopAndRecentlyPlayedTracksLoader {
     }
 
     fun getTopArtists(context: Context): ArrayList<Artist> {
-        return ArtistLoader.splitIntoArtists(getTopAlbums(context))
+        return ArrayList()
     }
 }

app/src/main/java/code/name/monkey/retromusic/misc/AsyncSearchResultLoader.kt

@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2019 Hemanth Savarala.
- *
- * Licensed under the GNU General Public License v3
- *
- * This is free software: you can redistribute it and/or modify it under
- * the terms of the GNU General Public License as published by
- *  the Free Software Foundation either version 3 of the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- * See the GNU General Public License for more details.
- */
-
-package code.name.monkey.retromusic.misc
-
-import android.content.Context
-import android.text.TextUtils
-import code.name.monkey.retromusic.R
-import code.name.monkey.retromusic.loaders.AlbumLoader
-import code.name.monkey.retromusic.loaders.ArtistLoader
-import code.name.monkey.retromusic.loaders.SongLoader
-import java.util.*
-
-internal class AsyncSearchResultLoader(context: Context, private val query: String) : WrappedAsyncTaskLoader<List<Any>>(context) {
-
-    override fun loadInBackground(): List<Any>? {
-        val results = ArrayList<Any>()
-        if (!TextUtils.isEmpty(query)) {
-            val songs = SongLoader.getSongs(context, query.trim { it <= ' ' })
-            if (!songs.isEmpty()) {
-                results.add(context.resources.getString(R.string.songs))
-                results.addAll(songs)
-            }
-
-            val artists = ArtistLoader.getArtists(context, query.trim { it <= ' ' })
-            if (!artists.isEmpty()) {
-                results.add(context.resources.getString(R.string.artists))
-                results.addAll(artists)
-            }
-
-            val albums = AlbumLoader.getAlbums(context, query.trim { it <= ' ' })
-            if (!albums.isEmpty()) {
-                results.add(context.resources.getString(R.string.albums))
-                results.addAll(albums)
-            }
-        }
-        return results
-    }
-}

app/src/main/java/code/name/monkey/retromusic/model/AbsCustomPlaylist.java

@@ -23,8 +23,6 @@ import org.jetbrains.annotations.NotNull;
 
 import java.util.ArrayList;
 
-import io.reactivex.Observable;
-
 /**
  * @author Karim Abou Zeid (kabouzeid)
  */
@@ -41,9 +39,6 @@ public abstract class AbsCustomPlaylist extends Playlist {
         super(in);
     }
 
-    @NonNull
-    public abstract Observable<ArrayList<Song>> getSongsFlowable(@NotNull Context context);
-
     @NonNull
     public abstract ArrayList<Song> getSongs(@NotNull Context context);
 }

app/src/main/java/code/name/monkey/retromusic/model/Album.kt

@@ -14,10 +14,8 @@
 
 package code.name.monkey.retromusic.model
 
-import java.util.*
 
-
+/*class Album {
-class Album {
     val songs: ArrayList<Song>?
 
     val id: Int
@@ -52,4 +50,12 @@ class Album {
     fun safeGetFirstSong(): Song {
         return if (songs!!.isEmpty()) Song.emptySong else songs[0]
     }
-}
+}*/
+
+class Album(
+        val id: Long = -1,
+        val title: String = "",
+        val artistName: String = "",
+        val artistId: Long = -1,
+        val songCount: Int = -1,
+        val year: Int = -1)

app/src/main/java/code/name/monkey/retromusic/model/Artist.kt

@@ -14,10 +14,8 @@
 
 package code.name.monkey.retromusic.model
 
-import code.name.monkey.retromusic.util.MusicUtil
-import java.util.*
-
 
+/*
 class Artist {
     val albums: ArrayList<Album>?
 
@@ -69,3 +67,11 @@ class Artist {
         const val UNKNOWN_ARTIST_DISPLAY_NAME = "Unknown Artist"
     }
 }
+*/
+
+
+class Artist(
+        val id: Long = -1,
+        val name: String = "",
+        val albumCount: Long = -1,
+        val songCount: Long = -1)

app/src/main/java/code/name/monkey/retromusic/model/smartplaylist/LastAddedPlaylist.java

@@ -49,11 +49,6 @@ public class LastAddedPlaylist extends AbsSmartPlaylist {
         super(in);
     }
 
-    @NonNull
-    @Override
-    public Observable<ArrayList<Song>> getSongsFlowable(@NotNull @NonNull Context context) {
-        return LastAddedSongsLoader.INSTANCE.getLastAddedSongsFlowable(context);
-    }
 
     @NonNull
     @Override

app/src/main/java/code/name/monkey/retromusic/mvp/presenter/AlbumDetailsPresenter.kt

@@ -14,19 +14,23 @@
 
 package code.name.monkey.retromusic.mvp.presenter
 
+import code.name.monkey.retromusic.Result
 import code.name.monkey.retromusic.model.Album
 import code.name.monkey.retromusic.model.Artist
+import code.name.monkey.retromusic.mvp.BaseView
 import code.name.monkey.retromusic.mvp.Presenter
 import code.name.monkey.retromusic.mvp.PresenterImpl
 import code.name.monkey.retromusic.providers.interfaces.Repository
 import io.reactivex.disposables.CompositeDisposable
+import kotlinx.coroutines.*
 import javax.inject.Inject
+import kotlin.coroutines.CoroutineContext
 
 
 /**
  * Created by hemanths on 20/08/17.
  */
-interface AlbumDetailsView {
+interface AlbumDetailsView : BaseView {
     fun album(album: Album)
 
     fun complete()
@@ -37,47 +41,64 @@ interface AlbumDetailsView {
 }
 
 interface AlbumDetailsPresenter : Presenter<AlbumDetailsView> {
-    fun loadAlbum(albumId: Int)
+    fun loadAlbum(albumId: Long)
 
-    fun loadMore(artistId: Int)
+    fun loadMore(artistId: Long)
 
     class AlbumDetailsPresenterImpl @Inject constructor(
             private val repository: Repository
-    ) : PresenterImpl<AlbumDetailsView>(), AlbumDetailsPresenter {
+    ) : PresenterImpl<AlbumDetailsView>(), AlbumDetailsPresenter, CoroutineScope {
 
+        private val job = Job()
         private lateinit var album: Album
         private var disposable: CompositeDisposable = CompositeDisposable()
-        override fun loadMore(artistId: Int) {
+
-            disposable += repository.getArtistByIdFlowable(artistId)
+        override val coroutineContext: CoroutineContext
-                    .map {
+            get() = Dispatchers.IO + job
-                        view?.loadArtistImage(it)
+
-                        return@map it.albums
+        override fun loadMore(artistId: Long) {
-                    }
+            /* disposable += repository.getArtistByIdFlowable(artistId)
-                    .map {
+                     .map {
-                        it.filter { filterAlbum -> album.id != filterAlbum.id }
+                         view?.loadArtistImage(it)
-                    }
+                         return@map it.albums
-                    .subscribe({
+                     }
-                        if (it.isEmpty()) {
+                     .map {
-                            return@subscribe
+                         it.filter { filterAlbum -> album.id != filterAlbum.id }
-                        }
+                     }
-                        view?.moreAlbums(ArrayList(it))
+                     .subscribe({
-                    }, { t -> println(t) })
+                         if (it.isEmpty()) {
+                             return@subscribe
+                         }
+                         view?.moreAlbums(ArrayList(it))
+                     }, { t -> println(t) })*/
         }
 
 
-        override fun loadAlbum(albumId: Int) {
+        override fun loadAlbum(albumId: Long) {
-            disposable += repository.getAlbumFlowable(albumId)
+
+            launch {
+                when (val result = repository.getAlbum(albumId)) {
+                    is Result.Success -> withContext(Dispatchers.Main) {
+                        view?.album(result.data)
+                    }
+                    is Result.Error -> withContext(Dispatchers.Main) {
+                        view?.showEmptyView()
+                    }
+                }
+            }
+            /*disposable += repository.getAlbum(albumId)
                     .doOnComplete {
                         view?.complete()
                     }
                     .subscribe({
                         album = it
                         view?.album(it)
-                    }, { t -> println(t) })
+                    }, { t -> println(t) })*/
         }
 
         override fun detachView() {
             super.detachView()
+            job.cancel()
             disposable.dispose()
         }
     }

app/src/main/java/code/name/monkey/retromusic/mvp/presenter/ArtistDetailsPresenter.kt

@@ -14,15 +14,20 @@
 
 package code.name.monkey.retromusic.mvp.presenter
 
+import code.name.monkey.retromusic.Result
+import code.name.monkey.retromusic.model.Album
 import code.name.monkey.retromusic.model.Artist
+import code.name.monkey.retromusic.model.Song
 import code.name.monkey.retromusic.mvp.BaseView
 import code.name.monkey.retromusic.mvp.Presenter
 import code.name.monkey.retromusic.mvp.PresenterImpl
 import code.name.monkey.retromusic.providers.interfaces.Repository
 import code.name.monkey.retromusic.rest.model.LastFmArtist
 import io.reactivex.disposables.CompositeDisposable
+import kotlinx.coroutines.*
 import java.util.*
 import javax.inject.Inject
+import kotlin.coroutines.CoroutineContext
 
 
 /**
@@ -30,13 +35,23 @@ import javax.inject.Inject
  */
 interface ArtistDetailsView : BaseView {
     fun artist(artist: Artist)
+
+    fun artistSong(songs: ArrayList<Song>)
+
+    fun artistAlbums(albums: ArrayList<Album>)
+
     fun artistInfo(lastFmArtist: LastFmArtist?)
+
     fun complete()
 }
 
 interface ArtistDetailsPresenter : Presenter<ArtistDetailsView> {
 
-    fun loadArtist(artistId: Int)
+    fun loadArtist(artistId: Long)
+
+    fun loadArtistSongs(artistId: Long)
+
+    fun loadArtistAlbums(artistId: Long)
 
     fun loadBiography(name: String,
                       lang: String? = Locale.getDefault().language,
@@ -44,7 +59,38 @@ interface ArtistDetailsPresenter : Presenter<ArtistDetailsView> {
 
     class ArtistDetailsPresenterImpl @Inject constructor(
             private val repository: Repository
-    ) : PresenterImpl<ArtistDetailsView>(), ArtistDetailsPresenter {
+    ) : PresenterImpl<ArtistDetailsView>(), ArtistDetailsPresenter, CoroutineScope {
+
+        override fun loadArtistAlbums(artistId: Long) {
+            launch {
+                when (val result = repository.getArtistAlbums(artistId)) {
+                    is Result.Success -> withContext(Dispatchers.Main) {
+                        view?.artistAlbums(result.data)
+                    }
+                    is Result.Error -> withContext(Dispatchers.Main) {
+                        view?.showEmptyView()
+                    }
+                }
+            }
+        }
+
+        override fun loadArtistSongs(artistId: Long) {
+            launch {
+                when (val result = repository.getArtistSongs(artistId)) {
+                    is Result.Success -> withContext(Dispatchers.Main) {
+                        view?.artistSong(result.data)
+                    }
+                    is Result.Error -> withContext(Dispatchers.Main) {
+                        view?.showEmptyView()
+                    }
+                }
+            }
+        }
+
+        override val coroutineContext: CoroutineContext
+            get() = Dispatchers.IO + job
+
+        private val job = Job()
 
         override fun loadBiography(name: String,
                                    lang: String?,
@@ -57,18 +103,23 @@ interface ArtistDetailsPresenter : Presenter<ArtistDetailsView> {
 
         private var disposable = CompositeDisposable()
 
-        override fun loadArtist(artistId: Int) {
+        override fun loadArtist(artistId: Long) {
-            disposable += repository.getArtistByIdFlowable(artistId)
+            launch {
-                    .doOnComplete {
+                when (val result = repository.getArtistById(artistId)) {
+                    is Result.Success -> withContext(Dispatchers.Main) {
+                        view?.artist(result.data)
                         view?.complete()
                     }
-                    .subscribe({
+                    is Result.Error -> withContext(Dispatchers.Main) {
-                        view?.artist(it)
+                        view?.showEmptyView()
-                    }, { t -> println(t) })
+                    }
+                }
+            }
         }
 
         override fun detachView() {
             super.detachView()
+            job.cancel()
             disposable.dispose()
         }
     }

app/src/main/java/code/name/monkey/retromusic/providers/RepositoryImpl.kt

@@ -33,7 +33,7 @@ class RepositoryImpl(private val context: Context) : Repository {
 
     override suspend fun allAlbums(): Result<ArrayList<Album>> {
         return try {
-            val albums = AlbumLoader.getAllAlbums(context)
+            val albums = AlbumLoader.allAlbums(context)
             if (albums.isNotEmpty()) {
                 Success(albums)
             } else {
@@ -230,6 +230,42 @@ class RepositoryImpl(private val context: Context) : Repository {
         }
     }
 
+    override suspend fun getArtistById(artistId: Long): Result<Artist> {
+        return try {
+            val artist = ArtistLoader.getArtist(context, artistId)
+            Success(artist)
+        } catch (er: Exception) {
+            Error(er)
+        }
+    }
+
+    override suspend fun getArtistSongs(artistId: Long): Result<ArrayList<Song>> {
+        return try {
+            val songs = ArtistLoader.artistSongs(context, artistId)
+            Success(songs)
+        } catch (er: Exception) {
+            Error(er)
+        }
+    }
+
+    override suspend fun getArtistAlbums(artistId: Long): Result<ArrayList<Album>> {
+        return try {
+            val albums = ArtistLoader.artistAlbums(context, artistId)
+            Success(albums)
+        } catch (er: Exception) {
+            Error(er)
+        }
+    }
+
+    override suspend fun getAlbum(albumId: Long): Result<Album> {
+        return try {
+            val album = AlbumLoader.getAlbum(context, albumId)
+            Success(album)
+        } catch (er: Exception) {
+            Error(er)
+        }
+    }
+
     override fun artistInfoFloable(
             name: String,
             lang: String?,
@@ -247,17 +283,11 @@ class RepositoryImpl(private val context: Context) : Repository {
                 .observeOn(AndroidSchedulers.mainThread())
     }
 
-    override fun getAlbumFlowable(albumId: Int): Observable<Album> {
+   /* override fun getAlbumFlowable(albumId: Int): Observable<Album> {
         return AlbumLoader.getAlbumFlowable(context, albumId)
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
-    }
+    }*/
-
-    override fun getArtistByIdFlowable(artistId: Int): Observable<Artist> {
-        return ArtistLoader.getArtistFlowable(context, artistId)
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
-    }
 
     override fun getPlaylistSongsFlowable(playlist: Playlist): Observable<ArrayList<Song>> {
         return PlaylistSongsLoader.getPlaylistSongListFlowable(context, playlist)
@@ -288,15 +318,12 @@ class RepositoryImpl(private val context: Context) : Repository {
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
 
-    override val allAlbumsFlowable: Observable<ArrayList<Album>>
+    /*override val allAlbumsFlowable: Observable<ArrayList<Album>>
         get() = AlbumLoader.getAllAlbumsFlowable(context)
                 .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
+                .observeOn(AndroidSchedulers.mainThread())*/
+
 
-    override val recentAlbumsFlowable: Observable<ArrayList<Album>>
-        get() = LastAddedSongsLoader.getLastAddedAlbumsFlowable(context)
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
 
     override val topAlbumsFlowable: Observable<ArrayList<Album>>
         get() = TopAndRecentlyPlayedTracksLoader.getTopAlbumsFlowable(context)
@@ -304,14 +331,8 @@ class RepositoryImpl(private val context: Context) : Repository {
                 .observeOn(AndroidSchedulers.mainThread())
 
     override val allArtistsFlowable: Observable<ArrayList<Artist>>
-        get() = ArtistLoader.getAllArtistsFlowable(context)
+        get() = Observable.just(ArrayList())
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
 
-    override val recentArtistsFlowable: Observable<ArrayList<Artist>>
-        get() = LastAddedSongsLoader.getLastAddedArtistsFlowable(context)
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
 
     override val topArtistsFlowable: Observable<ArrayList<Artist>>
         get() = TopAndRecentlyPlayedTracksLoader.getTopArtistsFlowable(context)
@@ -332,14 +353,4 @@ class RepositoryImpl(private val context: Context) : Repository {
     override fun getSong(id: Int): Song {
         return SongLoader.getSong(context, id)
     }
-
-    override fun getAlbum(albumId: Int): Album {
-        return AlbumLoader.getAlbum(context, albumId)
-    }
-
-    override fun getArtistById(artistId: Long): Artist {
-        return ArtistLoader.getArtist(context, artistId.toInt())
-    }
-
-
 }

app/src/main/java/code/name/monkey/retromusic/providers/interfaces/Repository.kt

@@ -51,19 +51,26 @@ interface Repository {
 
     suspend fun favoritePlaylist(): Result<Home>
 
+    suspend fun getArtistById(artistId: Long): Result<Artist>
+
+    suspend fun getArtistSongs(artistId: Long): Result<ArrayList<Song>>
+
+    suspend fun getArtistAlbums(artistId: Long): Result<ArrayList<Album>>
+
+   suspend fun getAlbum(albumId: Long): Result<Album>
+
     val allSongsFlowable: Observable<ArrayList<Song>>
 
     val suggestionSongsFlowable: Observable<ArrayList<Song>>
 
-    val allAlbumsFlowable: Observable<ArrayList<Album>>
+    //val allAlbumsFlowable: Observable<ArrayList<Album>>
+
 
-    val recentAlbumsFlowable: Observable<ArrayList<Album>>
 
     val topAlbumsFlowable: Observable<ArrayList<Album>>
 
     val allArtistsFlowable: Observable<ArrayList<Artist>>
 
-    val recentArtistsFlowable: Observable<ArrayList<Artist>>
 
     val topArtistsFlowable: Observable<ArrayList<Artist>>
 
@@ -75,13 +82,10 @@ interface Repository {
 
     fun getSong(id: Int): Song
 
-    fun getAlbumFlowable(albumId: Int): Observable<Album>
+    //fun getAlbumFlowable(albumId: Int): Observable<Album>
 
-    fun getAlbum(albumId: Int): Album
 
-    fun getArtistByIdFlowable(artistId: Int): Observable<Artist>
 
-    fun getArtistById(artistId: Long): Artist
 
     fun getPlaylistSongsFlowable(playlist: Playlist): Observable<ArrayList<Song>>
 

app/src/main/java/code/name/monkey/retromusic/service/WearBrowserService.java

@@ -33,12 +33,10 @@ import java.util.List;
 
 import code.name.monkey.retromusic.R;
 import code.name.monkey.retromusic.helper.MusicPlayerRemote;
-import code.name.monkey.retromusic.loaders.AlbumLoader;
 import code.name.monkey.retromusic.loaders.ArtistLoader;
 import code.name.monkey.retromusic.loaders.PlaylistLoader;
 import code.name.monkey.retromusic.loaders.PlaylistSongsLoader;
 import code.name.monkey.retromusic.loaders.SongLoader;
-import code.name.monkey.retromusic.model.Album;
 import code.name.monkey.retromusic.model.Artist;
 import code.name.monkey.retromusic.model.Playlist;
 import code.name.monkey.retromusic.model.Song;
@@ -196,7 +194,7 @@ public class WearBrowserService extends MediaBrowserService {
                     switch (Integer.parseInt(Character.toString(parentId.charAt(0)))) {
                         case TYPE_ARTIST:
                             List<Artist> artistList = ArtistLoader.INSTANCE.getAllArtists(mContext) ;
-                            for (Artist artist : artistList) {
+                            /*for (Artist artist : artistList) {
                                 String albumNmber = String.format("%d %s", artist.getAlbums().size(), artist.getAlbums().size() > 1 ? "Albums" : "Album");
                                 String songCount = String.format("%d %s", artist.getSongs().size(), artist.getSongs().size() > 1 ? "Songs" : "Song");
                                 fillMediaItems(mediaItems,
@@ -205,7 +203,7 @@ public class WearBrowserService extends MediaBrowserService {
                                         albumNmber + " • " + songCount,
                                         Uri.parse("android.resource://code.name.monkey.retromusic/drawable/default_artist_art"),
                                         MediaBrowser.MediaItem.FLAG_BROWSABLE);
-                            }
+                            }*/
                             break;
 
                         case TYPE_ARTIST_SONG_ALBUMS:
@@ -216,7 +214,7 @@ public class WearBrowserService extends MediaBrowserService {
                                     Uri.parse("android.resource://code.name.monkey.retromusic/drawable/default_artist_art"),
                                     MediaBrowser.MediaItem.FLAG_BROWSABLE);
 
-                            List<Album> artistAlbums = ArtistLoader.INSTANCE.getArtist(mContext, Integer.parseInt(parentId.substring(1))).getAlbums(); //ArtistAlbumLoader.getAlbumsForArtist(mContext, Long.parseLong(parentId.substring(1)));
+                            /*List<Album> artistAlbums = ArtistLoader.INSTANCE.getArtist(mContext, Integer.parseInt(parentId.substring(1))).getAlbums(); //ArtistAlbumLoader.getAlbumsForArtist(mContext, Long.parseLong(parentId.substring(1)));
                             for (Album album : artistAlbums) {
                                 String songCount = String.format("%d %s", album.getSongs().size(), album.getSongs().size() > 1 ? "Songs" : "Song");
                                 fillMediaItems(mediaItems,
@@ -225,10 +223,10 @@ public class WearBrowserService extends MediaBrowserService {
                                         songCount,
                                         Uri.parse("android.resource://code.name.monkey.retromusic/drawable/default_artist_art"),
                                         MediaBrowser.MediaItem.FLAG_BROWSABLE);
-                            }
+                            }*/
                             break;
                         case TYPE_ALBUM:
-                            List<Album> albumList = AlbumLoader.INSTANCE.getAllAlbums(mContext);
+                            /*List<Album> albumList = AlbumLoader.INSTANCE.getAllAlbums(mContext);
                             for (Album album : albumList) {
                                 fillMediaItems(mediaItems,
                                         Integer.toString(TYPE_ALBUM_SONGS) + Long.toString(album.getId()),
@@ -236,7 +234,7 @@ public class WearBrowserService extends MediaBrowserService {
                                         album.getArtistName(),
                                         RetroUtil.getAlbumArtUri(album.getId()),
                                         MediaBrowser.MediaItem.FLAG_BROWSABLE);
-                            }
+                            }*/
                             break;
                         case TYPE_SONG:
                             List<Song> songList = SongLoader.INSTANCE.getAllSongs(mContext);
@@ -251,7 +249,7 @@ public class WearBrowserService extends MediaBrowserService {
                             break;
 
                         case TYPE_ALBUM_SONGS:
-                            List<Song> albumSongList = AlbumLoader.INSTANCE.getAlbum(mContext, Integer.parseInt(parentId.substring(1))).getSongs();
+                            /*List<Song> albumSongList = AlbumLoader.INSTANCE.getAlbum(mContext, Integer.parseInt(parentId.substring(1))).getSongs();
                             for (Song song : albumSongList) {
                                 fillMediaItems(mediaItems,
                                         String.valueOf(song.getId()),
@@ -259,10 +257,10 @@ public class WearBrowserService extends MediaBrowserService {
                                         song.getAlbumName(),
                                         Uri.parse("android.resource://code.name.monkey.retromusic/drawable/default_album_art"),
                                         MediaBrowser.MediaItem.FLAG_PLAYABLE);
-                            }
+                            }*/
                             break;
                         case TYPE_ARTIST_ALL_SONGS:
-                            List<Song> artistSongs = ArtistLoader.INSTANCE.getArtist(mContext, Integer.parseInt(parentId.substring(1))).getSongs();
+                            /*List<Song> artistSongs = ArtistLoader.INSTANCE.getArtist(mContext, Integer.parseInt(parentId.substring(1))).getSongs();
                             for (Song song : artistSongs) {
                                 fillMediaItems(mediaItems,
                                         String.valueOf(song.getId()),
@@ -270,7 +268,7 @@ public class WearBrowserService extends MediaBrowserService {
                                         song.getAlbumName(),
                                         Uri.parse("android.resource://code.name.monkey.retromusic/drawable/default_album_art"),
                                         MediaBrowser.MediaItem.FLAG_PLAYABLE);
-                            }
+                            }*/
                             break;
                         case TYPE_PLAYLIST:
                             List<Playlist> playlistList = PlaylistLoader.INSTANCE.getAllPlaylists(mContext);

app/src/main/java/code/name/monkey/retromusic/util/MusicUtil.java

@@ -114,8 +114,8 @@ public class MusicUtil {
     @NonNull
     public static String getArtistInfoString(@NonNull final Context context,
                                              @NonNull final Artist artist) {
-        int albumCount = artist.getAlbumCount();
+        long albumCount = artist.getAlbumCount();
-        int songCount = artist.getSongCount();
+        long songCount = artist.getSongCount();
         String albumString = albumCount == 1 ? context.getResources().getString(R.string.album)
                 : context.getResources().getString(R.string.albums);
         String songString = songCount == 1 ? context.getResources().getString(R.string.song)
@@ -126,7 +126,7 @@ public class MusicUtil {
     @NonNull
     public static String getArtistInfoStringSmall(@NonNull final Context context,
                                                   @NonNull final Artist artist) {
-        int songCount = artist.getSongCount();
+        long songCount = artist.getSongCount();
         String songString = songCount == 1 ? context.getResources().getString(R.string.song)
                 : context.getResources().getString(R.string.songs);
         return songCount + " " + songString;
@@ -435,9 +435,9 @@ public class MusicUtil {
         if (TextUtils.isEmpty(artistName)) {
             return false;
         }
-        if (artistName.equals(Artist.UNKNOWN_ARTIST_DISPLAY_NAME)) {
+       /* if (artistName.equals(Artist.UNKNOWN_ARTIST_DISPLAY_NAME)) {
             return true;
-        }
+        }*/
         artistName = artistName.trim().toLowerCase();
         return artistName.equals("unknown") || artistName.equals("<unknown>");
     }

app/src/main/java/code/name/monkey/retromusic/util/NavigationUtil.java

@@ -70,7 +70,7 @@ public class NavigationUtil {
     }
 
     public static void goToArtistOptions(@NotNull AppCompatActivity activity,
-                                         int artistId,
+                                         long artistId,
                                          @NonNull ActivityOptions options) {
 
         Intent intent = new Intent(activity, ArtistDetailActivity.class);

app/src/main/java/code/name/monkey/retromusic/util/PreferenceUtil.java

@@ -245,7 +245,7 @@ public final class PreferenceUtil {
     }
 
     public final String getArtistAlbumSortOrder() {
-        return mPreferences.getString(ARTIST_ALBUM_SORT_ORDER, SortOrder.ArtistAlbumSortOrder.ALBUM_YEAR);
+        return mPreferences.getString(ARTIST_ALBUM_SORT_ORDER, SortOrder.ArtistAlbumSortOrder.ALBUM_A_Z);
     }
 
     public final String getAlbumSortOrder() {