Rx Java and Normal compatible for all query

app/src/main/java/code/name/monkey/retromusic/providers/BlacklistStore.java

@@ -22,14 +22,15 @@ import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.os.Environment;
 
+import androidx.annotation.NonNull;
+
 import java.io.File;
 import java.util.ArrayList;
 
-import androidx.annotation.NonNull;
 import code.name.monkey.retromusic.util.FileUtil;
 import code.name.monkey.retromusic.util.PreferenceUtil;
 
-import static code.name.monkey.retromusic.Constants.MEDIA_STORE_CHANGED;
+import static code.name.monkey.retromusic.service.MusicService.MEDIA_STORE_CHANGED;
 
 public class BlacklistStore extends SQLiteOpenHelper {
     public static final String DATABASE_NAME = "blacklist.db";

app/src/main/java/code/name/monkey/retromusic/providers/MusicPlaybackQueueStore.java

@@ -20,20 +20,20 @@ import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.provider.BaseColumns;
 import android.provider.MediaStore.Audio.AudioColumns;
+
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
-import code.name.monkey.retromusic.loaders.SongLoader;
-
 import java.util.ArrayList;
 
+import code.name.monkey.retromusic.loaders.SongLoader;
 import code.name.monkey.retromusic.model.Song;
 import io.reactivex.Observable;
 
 /**
  * @author Andrew Neal, modified for Phonograph by Karim Abou Zeid
- *         <p/>
- *         This keeps track of the music playback and history state of the playback service
+ * <p/>
+ * This keeps track of the music playback and history state of the playback service
  */
 public class MusicPlaybackQueueStore extends SQLiteOpenHelper {
     public static final String DATABASE_NAME = "music_playback_state.db";
@@ -187,17 +187,34 @@ public class MusicPlaybackQueueStore extends SQLiteOpenHelper {
     }
 
     @NonNull
-    public Observable<ArrayList<Song>> getSavedPlayingQueue() {
+    public Observable<ArrayList<Song>> getSavedPlayingQueueFlowable() {
+        return getQueueFlowable(PLAYING_QUEUE_TABLE_NAME);
+    }
+
+    @NonNull
+    public Observable<ArrayList<Song>> getSavedOriginalPlayingQueueFlowable() {
+        return getQueueFlowable(ORIGINAL_PLAYING_QUEUE_TABLE_NAME);
+    }
+
+    @NonNull
+    public ArrayList<Song> getSavedPlayingQueue() {
         return getQueue(PLAYING_QUEUE_TABLE_NAME);
     }
 
     @NonNull
-    public Observable<ArrayList<Song>> getSavedOriginalPlayingQueue() {
+    public ArrayList<Song> getSavedOriginalPlayingQueue() {
         return getQueue(ORIGINAL_PLAYING_QUEUE_TABLE_NAME);
     }
 
     @NonNull
-    private Observable<ArrayList<Song>> getQueue(@NonNull final String tableName) {
+    private Observable<ArrayList<Song>> getQueueFlowable(@NonNull final String tableName) {
+        Cursor cursor = getReadableDatabase().query(tableName, null,
+                null, null, null, null, null);
+        return SongLoader.INSTANCE.getSongsFlowable(cursor);
+    }
+
+    @NonNull
+    private ArrayList<Song> getQueue(@NonNull final String tableName) {
         Cursor cursor = getReadableDatabase().query(tableName, null,
                 null, null, null, null, null);
         return SongLoader.INSTANCE.getSongs(cursor);

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

@@ -18,113 +18,163 @@ import android.content.Context
 import code.name.monkey.retromusic.App
 import code.name.monkey.retromusic.loaders.*
 import code.name.monkey.retromusic.model.*
-import code.name.monkey.retromusic.model.smartplaylist.AbsSmartPlaylist
 import code.name.monkey.retromusic.providers.interfaces.Repository
 import io.reactivex.Observable
 import io.reactivex.android.schedulers.AndroidSchedulers
 import io.reactivex.schedulers.Schedulers
 
 class RepositoryImpl(private val context: Context) : Repository {
-    override val favoritePlaylist: Observable<ArrayList<Playlist>>
+    override fun search(query: String?): MutableList<Any> {
+        return SearchLoader.searchAll(context, query)
+    }
+
+    override fun allAlbums(): ArrayList<Album> {
+        return AlbumLoader.getAllAlbums(context)
+    }
+
+    override fun recentAlbums(): ArrayList<Album> {
+        return LastAddedSongsLoader.getLastAddedAlbums(context)
+    }
+
+    override fun topAlbums(): ArrayList<Album> {
+        return TopAndRecentlyPlayedTracksLoader.getTopAlbums(context)
+    }
+
+    override fun allArtists(): ArrayList<Artist> {
+        return ArtistLoader.getAllArtists(context)
+    }
+
+    override fun recentArtists(): ArrayList<Artist> {
+        return LastAddedSongsLoader.getLastAddedArtists(context)
+    }
+
+    override fun topArtists(): ArrayList<Artist> {
+        return TopAndRecentlyPlayedTracksLoader.getTopArtists(context)
+    }
+
+    override fun allPlaylists(): ArrayList<Playlist> {
+        return PlaylistLoader.getAllPlaylists(context)
+    }
+
+    override fun allGenres(): ArrayList<Genre> {
+        return GenreLoader.getAllGenres(context)
+    }
+
+    override fun getSongFlowable(id: Int): Observable<Song> {
+        return SongLoader.getSongFlowable(context, id)
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+    }
+
+    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)
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+    }
+
+    override fun getGenreFlowable(genreId: Int): Observable<ArrayList<Song>> {
+        return GenreLoader.getSongsFlowable(context, genreId)
+                .subscribeOn(Schedulers.io())
+                .observeOn(AndroidSchedulers.mainThread())
+    }
+
+    override val favoritePlaylist: ArrayList<Playlist>
         get() = PlaylistLoader.getFavoritePlaylist(context)
+
+    override fun allSongs(): ArrayList<Song> {
+        return SongLoader.getAllSongs(context)
+    }
+
+    override val favoritePlaylistFlowable: Observable<ArrayList<Playlist>>
+        get() = PlaylistLoader.getFavoritePlaylistFlowable(context)
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
 
 
-    override val allSongs: Observable<ArrayList<Song>>
-        get() = SongLoader.getAllSongs(context)
+    override val allSongsFlowable: Observable<ArrayList<Song>>
+        get() = SongLoader.getAllSongsFlowable(context)
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
 
-    override val suggestionSongs: Observable<ArrayList<Song>>
+    override val suggestionSongsFlowable: Observable<ArrayList<Song>>
         get() = SongLoader.suggestSongs(context)
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
 
-    override val allAlbums: Observable<ArrayList<Album>>
-        get() = AlbumLoader.getAllAlbums(context)
+    override val allAlbumsFlowable: Observable<ArrayList<Album>>
+        get() = AlbumLoader.getAllAlbumsFlowable(context)
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
 
-    override val recentAlbums: Observable<ArrayList<Album>>
-        get() = LastAddedSongsLoader.getLastAddedAlbums(context)
+    override val recentAlbumsFlowable: Observable<ArrayList<Album>>
+        get() = LastAddedSongsLoader.getLastAddedAlbumsFlowable(context)
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
 
-    override val topAlbums: Observable<ArrayList<Album>>
-        get() = TopAndRecentlyPlayedTracksLoader.getTopAlbums(context)
+    override val topAlbumsFlowable: Observable<ArrayList<Album>>
+        get() = TopAndRecentlyPlayedTracksLoader.getTopAlbumsFlowable(context)
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
 
-    override val allArtists: Observable<ArrayList<Artist>>
-        get() = ArtistLoader.getAllArtists(context)
+    override val allArtistsFlowable: Observable<ArrayList<Artist>>
+        get() = ArtistLoader.getAllArtistsFlowable(context)
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
 
-    override val recentArtists: Observable<ArrayList<Artist>>
-        get() = LastAddedSongsLoader.getLastAddedArtists(context)
+    override val recentArtistsFlowable: Observable<ArrayList<Artist>>
+        get() = LastAddedSongsLoader.getLastAddedArtistsFlowable(context)
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
 
-    override val topArtists: Observable<ArrayList<Artist>>
-        get() = TopAndRecentlyPlayedTracksLoader.getTopArtists(context)
+    override val topArtistsFlowable: Observable<ArrayList<Artist>>
+        get() = TopAndRecentlyPlayedTracksLoader.getTopArtistsFlowable(context)
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
 
-    override val allPlaylists: Observable<ArrayList<Playlist>>
-        get() = PlaylistLoader.getAllPlaylists(context)
+    override val allPlaylistsFlowable: Observable<ArrayList<Playlist>>
+        get() = PlaylistLoader.getAllPlaylistsFlowoable(context)
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
 
-    override val homeList: Observable<ArrayList<Playlist>>
-        get() = HomeLoader.getHomeLoader(context)
+
+    override val allGenresFlowable: Observable<ArrayList<Genre>>
+        get() = GenreLoader.getAllGenresFlowable(context)
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
 
-    override val allThings: Observable<ArrayList<AbsSmartPlaylist>>
-        get() = HomeLoader.getRecentAndTopThings(context)
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
-
-    override val allGenres: Observable<ArrayList<Genre>>
-        get() = GenreLoader.getAllGenres(context)
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
-
-    override fun getSong(id: Int): Observable<Song> {
+    override fun getSong(id: Int): Song {
         return SongLoader.getSong(context, id)
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
     }
 
-    override fun getAlbum(albumId: Int): Observable<Album> {
+    override fun getAlbum(albumId: Int): Album {
         return AlbumLoader.getAlbum(context, albumId)
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
     }
 
-    override fun getArtistById(artistId: Long): Observable<Artist> {
+    override fun getArtistById(artistId: Long): Artist {
         return ArtistLoader.getArtist(context, artistId.toInt())
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
     }
 
-    override fun search(query: String?): Observable<ArrayList<Any>> {
-        return SearchLoader.searchAll(context, query)
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
-    }
-
-    override fun getPlaylistSongs(playlist: Playlist): Observable<ArrayList<Song>> {
+    override fun getPlaylistSongs(playlist: Playlist): ArrayList<Song> {
         return PlaylistSongsLoader.getPlaylistSongList(context, playlist)
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
+
     }
 
-    override fun getGenre(genreId: Int): Observable<ArrayList<Song>> {
+    override fun getGenre(genreId: Int): ArrayList<Song> {
         return GenreLoader.getSongs(context, genreId)
-                .subscribeOn(Schedulers.io())
-                .observeOn(AndroidSchedulers.mainThread())
+
     }
 
 

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

@@ -15,9 +15,7 @@
 package code.name.monkey.retromusic.providers.interfaces
 
 import code.name.monkey.retromusic.model.*
-import code.name.monkey.retromusic.model.smartplaylist.AbsSmartPlaylist
 import io.reactivex.Observable
-import kotlin.collections.ArrayList
 
 /**
  * Created by hemanths on 11/08/17.
@@ -25,42 +23,68 @@ import kotlin.collections.ArrayList
 
 interface Repository {
 
-    val allSongs: Observable<ArrayList<Song>>
+    val allSongsFlowable: Observable<ArrayList<Song>>
 
-    val suggestionSongs: Observable<ArrayList<Song>>
+    fun allSongs(): ArrayList<Song>
 
-    val allAlbums: Observable<ArrayList<Album>>
+    val suggestionSongsFlowable: Observable<ArrayList<Song>>
 
-    val recentAlbums: Observable<ArrayList<Album>>
+    val allAlbumsFlowable: Observable<ArrayList<Album>>
 
-    val topAlbums: Observable<ArrayList<Album>>
+    fun allAlbums(): ArrayList<Album>
 
-    val allArtists: Observable<ArrayList<Artist>>
+    val recentAlbumsFlowable: Observable<ArrayList<Album>>
 
-    val recentArtists: Observable<ArrayList<Artist>>
+    fun recentAlbums(): ArrayList<Album>
 
-    val topArtists: Observable<ArrayList<Artist>>
+    val topAlbumsFlowable: Observable<ArrayList<Album>>
 
-    val allPlaylists: Observable<ArrayList<Playlist>>
+    fun topAlbums(): ArrayList<Album>
 
-    val homeList: Observable<ArrayList<Playlist>>
+    val allArtistsFlowable: Observable<ArrayList<Artist>>
 
-    val allThings: Observable<ArrayList<AbsSmartPlaylist>>
+    fun allArtists(): ArrayList<Artist>
 
-    val allGenres: Observable<ArrayList<Genre>>
+    val recentArtistsFlowable: Observable<ArrayList<Artist>>
 
-    fun getSong(id: Int): Observable<Song>
+    fun recentArtists(): ArrayList<Artist>
 
-    fun getAlbum(albumId: Int): Observable<Album>
+    val topArtistsFlowable: Observable<ArrayList<Artist>>
 
-    fun getArtistById(artistId: Long): Observable<Artist>
+    fun topArtists(): ArrayList<Artist>
 
-    fun search(query: String?): Observable<ArrayList<Any>>
+    val allPlaylistsFlowable: Observable<ArrayList<Playlist>>
 
-    fun getPlaylistSongs(playlist: Playlist): Observable<ArrayList<Song>>
+    fun allPlaylists(): ArrayList<Playlist>
 
-    fun getGenre(genreId: Int): Observable<ArrayList<Song>>
+    val allGenresFlowable: Observable<ArrayList<Genre>>
 
-    val favoritePlaylist: Observable<ArrayList<Playlist>>
+    fun allGenres(): ArrayList<Genre>
+
+    fun getSongFlowable(id: Int): Observable<Song>
+
+    fun getSong(id: Int): Song
+
+    fun getAlbumFlowable(albumId: Int): Observable<Album>
+
+    fun getAlbum(albumId: Int): Album
+
+    fun getArtistByIdFlowable(artistId: Int): Observable<Artist>
+
+    fun getArtistById(artistId: Long): Artist
+
+    fun search(query: String?): MutableList<Any>
+
+    fun getPlaylistSongsFlowable(playlist: Playlist): Observable<ArrayList<Song>>
+
+    fun getPlaylistSongs(playlist: Playlist): ArrayList<Song>
+
+    fun getGenreFlowable(genreId: Int): Observable<ArrayList<Song>>
+
+    fun getGenre(genreId: Int): ArrayList<Song>
+
+    val favoritePlaylistFlowable: Observable<ArrayList<Playlist>>
+
+    val favoritePlaylist: ArrayList<Playlist>
 
 }