Repackage to prepare for merge

app/src/main/java/code/name/monkey/retromusic/App.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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
+
+import androidx.multidex.MultiDexApplication
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.appthemehelper.util.VersionUtils
+import code.name.monkey.retromusic.appshortcuts.DynamicShortcutManager
+import org.koin.android.ext.koin.androidContext
+import org.koin.core.context.startKoin
+
+class App : MultiDexApplication() {
+
+    override fun onCreate() {
+        super.onCreate()
+        instance = this
+
+        startKoin {
+            androidContext(this@App)
+            modules(appModules)
+        }
+        // default theme
+        if (!ThemeStore.isConfigured(this, 3)) {
+            ThemeStore.editTheme(this)
+                .accentColorRes(R.color.md_deep_purple_A200)
+                .coloredNavigationBar(true)
+                .commit()
+        }
+
+        if (VersionUtils.hasNougatMR())
+            DynamicShortcutManager(this).initDynamicShortcuts()
+    }
+
+    companion object {
+        private var instance: App? = null
+
+        fun getContext(): App {
+            return instance!!
+        }
+    }
+}

app/src/main/java/code/name/monkey/retromusic/Constants.kt

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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
+
+import android.provider.BaseColumns
+import android.provider.MediaStore
+
+object Constants {
+    const val RATE_ON_GOOGLE_PLAY =
+        "https://play.google.com/store/apps/details?id=code.name.monkey.retromusic"
+    const val TRANSLATE = "https://github.com/h4h13/RetroMusicPlayer"
+    const val GITHUB_PROJECT = "https://github.com/MuntashirAkon/Metro"
+    const val TELEGRAM_CHANGE_LOG = "https://t.me/retromusiclog"
+    const val USER_PROFILE = "profile.jpg"
+    const val USER_BANNER = "banner.jpg"
+    const val APP_INSTAGRAM_LINK = "https://www.instagram.com/retromusicapp/"
+    const val APP_TELEGRAM_LINK = "https://t.me/retromusicapp/"
+    const val APP_TWITTER_LINK = "https://twitter.com/retromusicapp"
+    const val FAQ_LINK = "https://github.com/h4h13/RetroMusicPlayer/blob/master/FAQ.md"
+    const val PINTEREST = "https://in.pinterest.com/retromusicapp/"
+    const val AUDIO_SCROBBLER_URL = "https://ws.audioscrobbler.com/2.0/"
+
+    const val IS_MUSIC =
+        MediaStore.Audio.AudioColumns.IS_MUSIC + "=1" + " AND " + MediaStore.Audio.AudioColumns.TITLE + " != ''"
+
+    val baseProjection = arrayOf(
+        BaseColumns._ID, // 0
+        MediaStore.Audio.AudioColumns.TITLE, // 1
+        MediaStore.Audio.AudioColumns.TRACK, // 2
+        MediaStore.Audio.AudioColumns.YEAR, // 3
+        MediaStore.Audio.AudioColumns.DURATION, // 4
+        MediaStore.Audio.AudioColumns.DATA, // 5
+        MediaStore.Audio.AudioColumns.DATE_MODIFIED, // 6
+        MediaStore.Audio.AudioColumns.ALBUM_ID, // 7
+        MediaStore.Audio.AudioColumns.ALBUM, // 8
+        MediaStore.Audio.AudioColumns.ARTIST_ID, // 9
+        MediaStore.Audio.AudioColumns.ARTIST, // 10
+        MediaStore.Audio.AudioColumns.COMPOSER, // 11
+        "album_artist" // 12
+    )
+    const val NUMBER_OF_TOP_TRACKS = 99
+}
+const val EXTRA_PLAYLIST_TYPE = "type"
+const val EXTRA_GENRE = "extra_genre"
+const val EXTRA_PLAYLIST = "extra_playlist"
+const val EXTRA_PLAYLIST_ID = "extra_playlist_id"
+const val EXTRA_ALBUM_ID = "extra_album_id"
+const val EXTRA_ARTIST_ID = "extra_artist_id"
+const val EXTRA_SONG = "extra_songs"
+const val EXTRA_PLAYLISTS = "extra_playlists"
+const val LIBRARY_CATEGORIES = "library_categories"
+const val EXTRA_SONG_INFO = "extra_song_info"
+const val DESATURATED_COLOR = "desaturated_color"
+const val BLACK_THEME = "black_theme"
+const val KEEP_SCREEN_ON = "keep_screen_on"
+const val TOGGLE_HOME_BANNER = "toggle_home_banner"
+const val NOW_PLAYING_SCREEN_ID = "now_playing_screen_id"
+const val CAROUSEL_EFFECT = "carousel_effect"
+const val COLORED_NOTIFICATION = "colored_notification"
+const val CLASSIC_NOTIFICATION = "classic_notification"
+const val GAP_LESS_PLAYBACK = "gap_less_playback"
+const val ALBUM_ART_ON_LOCK_SCREEN = "album_art_on_lock_screen"
+const val BLURRED_ALBUM_ART = "blurred_album_art"
+const val NEW_BLUR_AMOUNT = "new_blur_amount"
+const val TOGGLE_HEADSET = "toggle_headset"
+const val GENERAL_THEME = "general_theme"
+const val ACCENT_COLOR = "accent_color"
+const val SHOULD_COLOR_APP_SHORTCUTS = "should_color_app_shortcuts"
+const val CIRCULAR_ALBUM_ART = "circular_album_art"
+const val USER_NAME = "user_name"
+const val TOGGLE_FULL_SCREEN = "toggle_full_screen"
+const val TOGGLE_VOLUME = "toggle_volume"
+const val ROUND_CORNERS = "corner_window"
+const val TOGGLE_GENRE = "toggle_genre"
+const val PROFILE_IMAGE_PATH = "profile_image_path"
+const val BANNER_IMAGE_PATH = "banner_image_path"
+const val ADAPTIVE_COLOR_APP = "adaptive_color_app"
+const val TOGGLE_SEPARATE_LINE = "toggle_separate_line"
+const val HOME_ARTIST_GRID_STYLE = "home_artist_grid_style"
+const val HOME_ALBUM_GRID_STYLE = "home_album_grid_style"
+const val TOGGLE_ADD_CONTROLS = "toggle_add_controls"
+const val ALBUM_COVER_STYLE = "album_cover_style_id"
+const val ALBUM_COVER_TRANSFORM = "album_cover_transform"
+const val TAB_TEXT_MODE = "tab_text_mode"
+const val LANGUAGE_NAME = "language_name"
+const val SLEEP_TIMER_FINISH_SONG = "sleep_timer_finish_song"
+const val ALBUM_GRID_STYLE = "album_grid_style_home"
+const val ARTIST_GRID_STYLE = "artist_grid_style_home"
+const val SAF_SDCARD_URI = "saf_sdcard_uri"
+const val SONG_SORT_ORDER = "song_sort_order"
+const val SONG_GRID_SIZE = "song_grid_size"
+const val GENRE_SORT_ORDER = "genre_sort_order"
+const val LAST_PAGE = "last_start_page"
+const val BLUETOOTH_PLAYBACK = "bluetooth_playback"
+const val INITIALIZED_BLACKLIST = "initialized_blacklist"
+const val ARTIST_SORT_ORDER = "artist_sort_order"
+const val ARTIST_ALBUM_SORT_ORDER = "artist_album_sort_order"
+const val ALBUM_SORT_ORDER = "album_sort_order"
+const val PLAYLIST_SORT_ORDER = "playlist_sort_order"
+const val ALBUM_SONG_SORT_ORDER = "album_song_sort_order"
+const val ARTIST_SONG_SORT_ORDER = "artist_song_sort_order"
+const val ALBUM_GRID_SIZE = "album_grid_size"
+const val ALBUM_GRID_SIZE_LAND = "album_grid_size_land"
+const val SONG_GRID_SIZE_LAND = "song_grid_size_land"
+const val ARTIST_GRID_SIZE = "artist_grid_size"
+const val ARTIST_GRID_SIZE_LAND = "artist_grid_size_land"
+const val COLORED_APP_SHORTCUTS = "colored_app_shortcuts"
+const val AUDIO_DUCKING = "audio_ducking"
+const val LAST_ADDED_CUTOFF = "last_added_interval"
+const val LAST_SLEEP_TIMER_VALUE = "last_sleep_timer_value"
+const val NEXT_SLEEP_TIMER_ELAPSED_REALTIME = "next_sleep_timer_elapsed_real_time"
+const val IGNORE_MEDIA_STORE_ARTWORK = "ignore_media_store_artwork"
+const val LAST_CHANGELOG_VERSION = "last_changelog_version"
+const val AUTO_DOWNLOAD_IMAGES_POLICY = "auto_download_images_policy"
+const val START_DIRECTORY = "start_directory"
+const val RECENTLY_PLAYED_CUTOFF = "recently_played_interval"
+const val LOCK_SCREEN = "lock_screen"
+const val ALBUM_ARTISTS_ONLY = "album_artists_only"
+const val ALBUM_DETAIL_SONG_SORT_ORDER = "album_detail_song_sort_order"
+const val LYRICS_OPTIONS = "lyrics_tab_position"
+const val CHOOSE_EQUALIZER = "choose_equalizer"
+const val EQUALIZER = "equalizer"
+const val TOGGLE_SHUFFLE = "toggle_shuffle"
+const val SONG_GRID_STYLE = "song_grid_style"
+const val PAUSE_ON_ZERO_VOLUME = "pause_on_zero_volume"
+const val FILTER_SONG = "filter_song"
+const val EXPAND_NOW_PLAYING_PANEL = "expand_now_playing_panel"

app/src/main/java/code/name/monkey/retromusic/HomeSection.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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
+
+import androidx.annotation.IntDef
+
+@IntDef(
+    RECENT_ALBUMS,
+    TOP_ALBUMS,
+    RECENT_ARTISTS,
+    TOP_ARTISTS,
+    SUGGESTIONS,
+    FAVOURITES,
+    GENRES,
+    PLAYLISTS
+)
+@Retention(AnnotationRetention.SOURCE)
+annotation class HomeSection
+
+const val RECENT_ALBUMS = 3
+const val TOP_ALBUMS = 1
+const val RECENT_ARTISTS = 2
+const val TOP_ARTISTS = 0
+const val SUGGESTIONS = 5
+const val FAVOURITES = 4
+const val GENRES = 6
+const val PLAYLISTS = 7
+const val HISTORY_PLAYLIST = 8
+const val LAST_ADDED_PLAYLIST = 9
+const val TOP_PLAYED_PLAYLIST = 10

app/src/main/java/code/name/monkey/retromusic/LanguageContextWrapper.java

@@ -0,0 +1,41 @@
+package code.name.monkey.retromusic;
+
+import android.content.Context;
+import android.content.ContextWrapper;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.os.LocaleList;
+import code.name.monkey.appthemehelper.util.VersionUtils;
+import java.util.Locale;
+
+public class LanguageContextWrapper extends ContextWrapper {
+
+  public LanguageContextWrapper(Context base) {
+    super(base);
+  }
+
+  public static LanguageContextWrapper wrap(Context context, Locale newLocale) {
+    Resources res = context.getResources();
+    Configuration configuration = res.getConfiguration();
+
+    if (VersionUtils.INSTANCE.hasNougatMR()) {
+      configuration.setLocale(newLocale);
+
+      LocaleList localeList = new LocaleList(newLocale);
+      LocaleList.setDefault(localeList);
+      configuration.setLocales(localeList);
+
+      context = context.createConfigurationContext(configuration);
+
+    } else if (VersionUtils.INSTANCE.hasLollipop()) {
+      configuration.setLocale(newLocale);
+      context = context.createConfigurationContext(configuration);
+
+    } else {
+      configuration.locale = newLocale;
+      res.updateConfiguration(configuration, res.getDisplayMetrics());
+    }
+
+    return new LanguageContextWrapper(context);
+  }
+}

app/src/main/java/code/name/monkey/retromusic/MainModule.kt

@@ -0,0 +1,192 @@
+package code.name.monkey.retromusic
+
+import androidx.room.Room
+import androidx.room.RoomDatabase
+import androidx.sqlite.db.SupportSQLiteDatabase
+import code.name.monkey.retromusic.db.BlackListStoreDao
+import code.name.monkey.retromusic.db.BlackListStoreEntity
+import code.name.monkey.retromusic.db.PlaylistWithSongs
+import code.name.monkey.retromusic.db.RetroDatabase
+import code.name.monkey.retromusic.fragments.LibraryViewModel
+import code.name.monkey.retromusic.fragments.albums.AlbumDetailsViewModel
+import code.name.monkey.retromusic.fragments.artists.ArtistDetailsViewModel
+import code.name.monkey.retromusic.fragments.genres.GenreDetailsViewModel
+import code.name.monkey.retromusic.fragments.playlists.PlaylistDetailsViewModel
+import code.name.monkey.retromusic.model.Genre
+import code.name.monkey.retromusic.network.provideDefaultCache
+import code.name.monkey.retromusic.network.provideLastFmRest
+import code.name.monkey.retromusic.network.provideLastFmRetrofit
+import code.name.monkey.retromusic.network.provideOkHttp
+import code.name.monkey.retromusic.repository.*
+import code.name.monkey.retromusic.util.FilePathUtil
+import kotlinx.coroutines.Dispatchers.IO
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import org.koin.android.ext.koin.androidContext
+import org.koin.androidx.viewmodel.dsl.viewModel
+import org.koin.dsl.bind
+import org.koin.dsl.module
+
+val networkModule = module {
+
+    factory {
+        provideDefaultCache()
+    }
+    factory {
+        provideOkHttp(get(), get())
+    }
+    single {
+        provideLastFmRetrofit(get())
+    }
+    single {
+        provideLastFmRest(get())
+    }
+}
+
+private val roomModule = module {
+
+    single {
+        Room.databaseBuilder(androidContext(), RetroDatabase::class.java, "playlist.db")
+            .allowMainThreadQueries()
+            .addCallback(object : RoomDatabase.Callback() {
+                override fun onOpen(db: SupportSQLiteDatabase) {
+                    super.onOpen(db)
+                    GlobalScope.launch(IO) {
+                        FilePathUtil.blacklistFilePaths().map {
+                            get<BlackListStoreDao>().insertBlacklistPath(BlackListStoreEntity(it))
+                        }
+                    }
+                }
+            })
+            .fallbackToDestructiveMigration()
+            .build()
+    }
+    factory {
+        get<RetroDatabase>().lyricsDao()
+    }
+
+    factory {
+        get<RetroDatabase>().playlistDao()
+    }
+
+    factory {
+        get<RetroDatabase>().blackListStore()
+    }
+
+    factory {
+        get<RetroDatabase>().playCountDao()
+    }
+
+    factory {
+        get<RetroDatabase>().historyDao()
+    }
+
+    single {
+        RealRoomRepository(get(), get(), get(), get(), get())
+    } bind RoomRepository::class
+}
+private val mainModule = module {
+    single {
+        androidContext().contentResolver
+    }
+}
+private val dataModule = module {
+    single {
+        RealRepository(
+            get(),
+            get(),
+            get(),
+            get(),
+            get(),
+            get(),
+            get(),
+            get(),
+            get(),
+            get(),
+            get(),
+            get(),
+        )
+    } bind Repository::class
+
+    single {
+        RealSongRepository(get())
+    } bind SongRepository::class
+
+    single {
+        RealGenreRepository(get(), get())
+    } bind GenreRepository::class
+
+    single {
+        RealAlbumRepository(get())
+    } bind AlbumRepository::class
+
+    single {
+        RealArtistRepository(get(), get())
+    } bind ArtistRepository::class
+
+    single {
+        RealPlaylistRepository(get())
+    } bind PlaylistRepository::class
+
+    single {
+        RealTopPlayedRepository(get(), get(), get(), get())
+    } bind TopPlayedRepository::class
+
+    single {
+        RealLastAddedRepository(
+            get(),
+            get(),
+            get()
+        )
+    } bind LastAddedRepository::class
+
+    single {
+        RealSearchRepository(
+            get(),
+            get(),
+            get(),
+            get(),
+            get()
+        )
+    }
+    single {
+        RealLocalDataRepository(get())
+    } bind LocalDataRepository::class
+}
+
+private val viewModules = module {
+
+    viewModel {
+        LibraryViewModel(get())
+    }
+
+    viewModel { (albumId: Long) ->
+        AlbumDetailsViewModel(
+            get(),
+            albumId
+        )
+    }
+
+    viewModel { (artistId: Long) ->
+        ArtistDetailsViewModel(
+            get(),
+            artistId
+        )
+    }
+
+    viewModel { (playlist: PlaylistWithSongs) ->
+        PlaylistDetailsViewModel(
+            get(),
+            playlist
+        )
+    }
+
+    viewModel { (genre: Genre) ->
+        GenreDetailsViewModel(
+            get(),
+            genre
+        )
+    }
+}
+
+val appModules = listOf(mainModule, dataModule, viewModules, networkModule, roomModule)

app/src/main/java/code/name/monkey/retromusic/PeekingLinearLayoutManager.kt

@@ -0,0 +1,46 @@
+package code.name.monkey.retromusic
+
+import android.content.Context
+import android.util.AttributeSet
+import android.view.ViewGroup
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+
+class PeekingLinearLayoutManager : LinearLayoutManager {
+    @JvmOverloads
+    constructor(
+        context: Context?,
+        @RecyclerView.Orientation orientation: Int = RecyclerView.VERTICAL,
+        reverseLayout: Boolean = false
+    ) : super(context, orientation, reverseLayout)
+
+    constructor(context: Context, attrs: AttributeSet, defStyleAttr: Int, defStyleRes: Int) : super(
+        context,
+        attrs,
+        defStyleAttr,
+        defStyleRes
+    )
+
+    override fun generateDefaultLayoutParams() =
+        scaledLayoutParams(super.generateDefaultLayoutParams())
+
+    override fun generateLayoutParams(lp: ViewGroup.LayoutParams?) =
+        scaledLayoutParams(super.generateLayoutParams(lp))
+
+    override fun generateLayoutParams(c: Context?, attrs: AttributeSet?) =
+        scaledLayoutParams(super.generateLayoutParams(c, attrs))
+
+    private fun scaledLayoutParams(layoutParams: RecyclerView.LayoutParams) =
+        layoutParams.apply {
+            when (orientation) {
+                HORIZONTAL -> width = (horizontalSpace * ratio).toInt()
+                VERTICAL -> height = (verticalSpace * ratio).toInt()
+            }
+        }
+
+    private val horizontalSpace get() = width - paddingStart - paddingEnd
+
+    private val verticalSpace get() = height - paddingTop - paddingBottom
+
+    private val ratio = 0.8f // change to 0.7f for 70%
+}

app/src/main/java/code/name/monkey/retromusic/RetroBottomSheetBehavior.java

@@ -0,0 +1,35 @@
+package code.name.monkey.retromusic;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.View;
+import androidx.coordinatorlayout.widget.CoordinatorLayout;
+import com.google.android.material.bottomsheet.BottomSheetBehavior;
+import org.jetbrains.annotations.NotNull;
+
+public class RetroBottomSheetBehavior<V extends View> extends BottomSheetBehavior<V> {
+
+  private static final String TAG = "RetroBottomSheetBehavior";
+
+  private boolean allowDragging = true;
+
+  public RetroBottomSheetBehavior() {}
+
+  public RetroBottomSheetBehavior(Context context, AttributeSet attrs) {
+    super(context, attrs);
+  }
+
+  public void setAllowDragging(boolean allowDragging) {
+    this.allowDragging = allowDragging;
+  }
+
+  @Override
+  public boolean onInterceptTouchEvent(
+      @NotNull CoordinatorLayout parent, @NotNull V child, @NotNull MotionEvent event) {
+    if (!allowDragging) {
+      return false;
+    }
+    return super.onInterceptTouchEvent(parent, child, event);
+  }
+}

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

@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities
+
+import android.animation.ObjectAnimator
+import android.graphics.Color
+import android.graphics.PorterDuff
+import android.os.Bundle
+import android.view.animation.LinearInterpolator
+import android.widget.SeekBar
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.base.AbsMusicServiceActivity
+import code.name.monkey.retromusic.fragments.base.AbsPlayerControlsFragment
+import code.name.monkey.retromusic.glide.BlurTransformation
+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.MusicProgressViewUpdateHelper
+import code.name.monkey.retromusic.helper.MusicProgressViewUpdateHelper.Callback
+import code.name.monkey.retromusic.helper.PlayPauseButtonOnClickHandler
+import code.name.monkey.retromusic.misc.SimpleOnSeekbarChangeListener
+import code.name.monkey.retromusic.service.MusicService
+import code.name.monkey.retromusic.util.MusicUtil
+import code.name.monkey.retromusic.util.color.MediaNotificationProcessor
+import com.bumptech.glide.Glide
+import kotlinx.android.synthetic.main.activity_drive_mode.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+/**
+ * Created by hemanths on 2020-02-02.
+ */
+
+class DriveModeActivity : AbsMusicServiceActivity(), Callback {
+
+    private var lastPlaybackControlsColor: Int = Color.GRAY
+    private var lastDisabledPlaybackControlsColor: Int = Color.GRAY
+    private lateinit var progressViewUpdateHelper: MusicProgressViewUpdateHelper
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_drive_mode)
+        setUpMusicControllers()
+
+        progressViewUpdateHelper = MusicProgressViewUpdateHelper(this)
+        lastPlaybackControlsColor = ThemeStore.accentColor(this)
+        close.setOnClickListener {
+            onBackPressed()
+        }
+    }
+
+    private fun setUpMusicControllers() {
+        setUpPlayPauseFab()
+        setUpPrevNext()
+        setUpRepeatButton()
+        setUpShuffleButton()
+        setUpProgressSlider()
+        setupFavouriteToggle()
+    }
+
+    private fun setupFavouriteToggle() {
+        songFavourite.setOnClickListener {
+            MusicUtil.toggleFavorite(
+                this@DriveModeActivity,
+                MusicPlayerRemote.currentSong
+            )
+        }
+    }
+
+    private fun toggleFavourite() {
+        CoroutineScope(Dispatchers.IO).launch {
+            val isFavourite =
+                MusicUtil.isFavorite(this@DriveModeActivity, MusicPlayerRemote.currentSong)
+            withContext(Dispatchers.Main) {
+                songFavourite.setImageResource(if (isFavourite) R.drawable.ic_favorite else R.drawable.ic_favorite_border)
+            }
+        }
+    }
+
+    private fun setUpProgressSlider() {
+        progressSlider.setOnSeekBarChangeListener(object : SimpleOnSeekbarChangeListener() {
+            override fun onProgressChanged(seekBar: SeekBar, progress: Int, fromUser: Boolean) {
+                if (fromUser) {
+                    MusicPlayerRemote.seekTo(progress)
+                    onUpdateProgressViews(
+                        MusicPlayerRemote.songProgressMillis,
+                        MusicPlayerRemote.songDurationMillis
+                    )
+                }
+            }
+        })
+    }
+
+    override fun onPause() {
+        super.onPause()
+        progressViewUpdateHelper.stop()
+    }
+
+    override fun onResume() {
+        super.onResume()
+        progressViewUpdateHelper.start()
+    }
+
+    private fun setUpPrevNext() {
+
+        nextButton.setOnClickListener { MusicPlayerRemote.playNextSong() }
+        previousButton.setOnClickListener { MusicPlayerRemote.back() }
+    }
+
+    private fun setUpShuffleButton() {
+        shuffleButton.setOnClickListener { MusicPlayerRemote.toggleShuffleMode() }
+    }
+
+    private fun setUpRepeatButton() {
+        repeatButton.setOnClickListener { MusicPlayerRemote.cycleRepeatMode() }
+    }
+
+    private fun setUpPlayPauseFab() {
+        playPauseButton.setOnClickListener(PlayPauseButtonOnClickHandler())
+    }
+
+    override fun onRepeatModeChanged() {
+        super.onRepeatModeChanged()
+        updateRepeatState()
+    }
+
+    override fun onShuffleModeChanged() {
+        super.onShuffleModeChanged()
+        updateShuffleState()
+    }
+
+    override fun onPlayStateChanged() {
+        super.onPlayStateChanged()
+        updatePlayPauseDrawableState()
+    }
+
+    override fun onServiceConnected() {
+        super.onServiceConnected()
+        updatePlayPauseDrawableState()
+        updateSong()
+        updateRepeatState()
+        updateShuffleState()
+        toggleFavourite()
+    }
+
+    private fun updatePlayPauseDrawableState() {
+        if (MusicPlayerRemote.isPlaying) {
+            playPauseButton.setImageResource(R.drawable.ic_pause)
+        } else {
+            playPauseButton.setImageResource(R.drawable.ic_play_arrow)
+        }
+    }
+
+    fun updateShuffleState() {
+        when (MusicPlayerRemote.shuffleMode) {
+            MusicService.SHUFFLE_MODE_SHUFFLE -> shuffleButton.setColorFilter(
+                lastPlaybackControlsColor,
+                PorterDuff.Mode.SRC_IN
+            )
+            else -> shuffleButton.setColorFilter(
+                lastDisabledPlaybackControlsColor,
+                PorterDuff.Mode.SRC_IN
+            )
+        }
+    }
+
+    private fun updateRepeatState() {
+        when (MusicPlayerRemote.repeatMode) {
+            MusicService.REPEAT_MODE_NONE -> {
+                repeatButton.setImageResource(R.drawable.ic_repeat)
+                repeatButton.setColorFilter(
+                    lastDisabledPlaybackControlsColor,
+                    PorterDuff.Mode.SRC_IN
+                )
+            }
+            MusicService.REPEAT_MODE_ALL -> {
+                repeatButton.setImageResource(R.drawable.ic_repeat)
+                repeatButton.setColorFilter(lastPlaybackControlsColor, PorterDuff.Mode.SRC_IN)
+            }
+            MusicService.REPEAT_MODE_THIS -> {
+                repeatButton.setImageResource(R.drawable.ic_repeat_one)
+                repeatButton.setColorFilter(lastPlaybackControlsColor, PorterDuff.Mode.SRC_IN)
+            }
+        }
+    }
+
+    override fun onPlayingMetaChanged() {
+        super.onPlayingMetaChanged()
+        updateSong()
+        toggleFavourite()
+    }
+
+    private fun updateSong() {
+        val song = MusicPlayerRemote.currentSong
+
+        songTitle.text = song.title
+        songText.text = song.artistName
+
+        SongGlideRequest.Builder.from(Glide.with(this), song)
+            .checkIgnoreMediaStore(this)
+            .generatePalette(this)
+            .build()
+            .transform(BlurTransformation.Builder(this).build())
+            .into(object : RetroMusicColoredTarget(image) {
+                override fun onColorReady(colors: MediaNotificationProcessor) {
+                }
+            })
+    }
+
+    override fun onUpdateProgressViews(progress: Int, total: Int) {
+        progressSlider.max = total
+
+        val animator = ObjectAnimator.ofInt(progressSlider, "progress", progress)
+        animator.duration = AbsPlayerControlsFragment.SLIDER_ANIMATION_TIME
+        animator.interpolator = LinearInterpolator()
+        animator.start()
+
+        songTotalTime.text = MusicUtil.getReadableDurationString(total.toLong())
+        songCurrentProgress.text = MusicUtil.getReadableDurationString(progress.toLong())
+    }
+}

app/src/main/java/code/name/monkey/retromusic/activities/LicenseActivity.java

@@ -0,0 +1,103 @@
+/*
+ * 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.activities;
+
+import android.graphics.Color;
+import android.os.Bundle;
+import android.view.MenuItem;
+import android.webkit.WebView;
+import androidx.annotation.NonNull;
+import androidx.appcompat.widget.Toolbar;
+import code.name.monkey.appthemehelper.ThemeStore;
+import code.name.monkey.appthemehelper.util.ATHUtil;
+import code.name.monkey.appthemehelper.util.ColorUtil;
+import code.name.monkey.appthemehelper.util.ToolbarContentTintHelper;
+import code.name.monkey.retromusic.R;
+import code.name.monkey.retromusic.activities.base.AbsBaseActivity;
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import org.jetbrains.annotations.Nullable;
+
+/** Created by hemanths on 2019-09-27. */
+public class LicenseActivity extends AbsBaseActivity {
+
+  @Override
+  protected void onCreate(@Nullable Bundle savedInstanceState) {
+    setDrawUnderStatusBar();
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.activity_license);
+    setStatusbarColorAuto();
+    setNavigationbarColorAuto();
+    setLightNavigationBar(true);
+    Toolbar toolbar = findViewById(R.id.toolbar);
+    setSupportActionBar(toolbar);
+    ToolbarContentTintHelper.colorBackButton(toolbar);
+    toolbar.setBackgroundColor(ATHUtil.INSTANCE.resolveColor(this, R.attr.colorSurface));
+    WebView webView = findViewById(R.id.license);
+    try {
+      StringBuilder buf = new StringBuilder();
+      InputStream json = getAssets().open("oldindex.html");
+      BufferedReader in = new BufferedReader(new InputStreamReader(json, StandardCharsets.UTF_8));
+      String str;
+      while ((str = in.readLine()) != null) {
+        buf.append(str);
+      }
+      in.close();
+
+      // Inject color values for WebView body background and links
+      final boolean isDark = ATHUtil.INSTANCE.isWindowBackgroundDark(this);
+      final String backgroundColor =
+          colorToCSS(
+              ATHUtil.INSTANCE.resolveColor(
+                  this, R.attr.colorSurface, Color.parseColor(isDark ? "#424242" : "#ffffff")));
+      final String contentColor = colorToCSS(Color.parseColor(isDark ? "#ffffff" : "#000000"));
+      final String changeLog =
+          buf.toString()
+              .replace(
+                  "{style-placeholder}",
+                  String.format(
+                      "body { background-color: %s; color: %s; }", backgroundColor, contentColor))
+              .replace("{link-color}", colorToCSS(ThemeStore.Companion.accentColor(this)))
+              .replace(
+                  "{link-color-active}",
+                  colorToCSS(
+                      ColorUtil.INSTANCE.lightenColor(ThemeStore.Companion.accentColor(this))));
+
+      webView.loadData(changeLog, "text/html", "UTF-8");
+    } catch (Throwable e) {
+      webView.loadData(
+          "<h1>Unable to load</h1><p>" + e.getLocalizedMessage() + "</p>", "text/html", "UTF-8");
+    }
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(@NonNull MenuItem item) {
+    if (item.getItemId() == android.R.id.home) {
+      onBackPressed();
+      return true;
+    }
+    return super.onOptionsItemSelected(item);
+  }
+
+  private String colorToCSS(int color) {
+    return String.format(
+        "rgb(%d, %d, %d)",
+        Color.red(color),
+        Color.green(color),
+        Color.blue(color)); // on API 29, WebView doesn't load with hex colors
+  }
+}

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

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities
+
+import android.app.KeyguardManager
+import android.content.Context
+import android.os.Build
+import android.os.Bundle
+import android.view.View
+import android.view.WindowManager
+import androidx.core.view.ViewCompat
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.base.AbsMusicServiceActivity
+import code.name.monkey.retromusic.extensions.whichFragment
+import code.name.monkey.retromusic.fragments.player.lockscreen.LockScreenControlsFragment
+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.util.color.MediaNotificationProcessor
+import com.bumptech.glide.Glide
+import com.r0adkll.slidr.Slidr
+import com.r0adkll.slidr.model.SlidrConfig
+import com.r0adkll.slidr.model.SlidrListener
+import com.r0adkll.slidr.model.SlidrPosition
+import kotlinx.android.synthetic.main.activity_lock_screen.*
+
+class LockScreenActivity : AbsMusicServiceActivity() {
+    private var fragment: LockScreenControlsFragment? = null
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        lockScreenInit()
+        setContentView(R.layout.activity_lock_screen)
+        hideStatusBar()
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setTaskDescriptionColorAuto()
+        setLightNavigationBar(true)
+
+        val config = SlidrConfig.Builder().listener(object : SlidrListener {
+            override fun onSlideStateChanged(state: Int) {
+            }
+
+            override fun onSlideChange(percent: Float) {
+            }
+
+            override fun onSlideOpened() {
+            }
+
+            override fun onSlideClosed(): Boolean {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                    val keyguardManager =
+                        getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
+                    keyguardManager.requestDismissKeyguard(this@LockScreenActivity, null)
+                }
+                finish()
+                return true
+            }
+        }).position(SlidrPosition.BOTTOM).build()
+
+        Slidr.attach(this, config)
+
+        fragment = whichFragment<LockScreenControlsFragment>(R.id.playback_controls_fragment)
+
+        findViewById<View>(R.id.slide).apply {
+            translationY = 100f
+            alpha = 0f
+            ViewCompat.animate(this).translationY(0f).alpha(1f).setDuration(1500).start()
+        }
+    }
+
+    private fun lockScreenInit() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+            setShowWhenLocked(true)
+            val keyguardManager: KeyguardManager = getSystemService(KeyguardManager::class.java)
+            keyguardManager.requestDismissKeyguard(this, null)
+        } else {
+            this.window.addFlags(
+                WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD or
+                        WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
+            )
+        }
+    }
+
+    override fun onPlayingMetaChanged() {
+        super.onPlayingMetaChanged()
+        updateSongs()
+    }
+
+    override fun onServiceConnected() {
+        super.onServiceConnected()
+        updateSongs()
+    }
+
+    private fun updateSongs() {
+        val song = MusicPlayerRemote.currentSong
+        SongGlideRequest.Builder.from(Glide.with(this), song).checkIgnoreMediaStore(this)
+            .generatePalette(this).build().dontAnimate()
+            .into(object : RetroMusicColoredTarget(image) {
+                override fun onColorReady(colors: MediaNotificationProcessor) {
+                    fragment?.setColor(colors)
+                }
+            })
+    }
+}

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

@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities
+
+import android.os.Bundle
+import android.view.Menu
+import android.view.MenuItem
+import android.view.WindowManager
+import androidx.core.view.ViewCompat
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.appthemehelper.util.ToolbarContentTintHelper
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.base.AbsMusicServiceActivity
+import code.name.monkey.retromusic.extensions.surfaceColor
+import code.name.monkey.retromusic.helper.MusicPlayerRemote
+import code.name.monkey.retromusic.helper.MusicProgressViewUpdateHelper
+import code.name.monkey.retromusic.lyrics.LrcView
+import code.name.monkey.retromusic.model.Song
+import code.name.monkey.retromusic.util.LyricUtil
+import code.name.monkey.retromusic.util.RetroUtil
+import com.google.android.material.color.MaterialColors
+import com.google.android.material.transition.platform.MaterialContainerTransform
+import kotlinx.android.synthetic.main.activity_lyrics.*
+
+class LyricsActivity : AbsMusicServiceActivity(), MusicProgressViewUpdateHelper.Callback {
+    private lateinit var updateHelper: MusicProgressViewUpdateHelper
+
+    private lateinit var song: Song
+
+    private val googleSearchLrcUrl: String
+        get() {
+            var baseUrl = "http://www.google.com/search?"
+            var query = song.title + "+" + song.artistName
+            query = "q=" + query.replace(" ", "+") + " .lrc"
+            baseUrl += query
+            return baseUrl
+        }
+
+    private fun buildContainerTransform(): MaterialContainerTransform {
+        val transform = MaterialContainerTransform()
+        transform.setAllContainerColors(
+            MaterialColors.getColor(findViewById(R.id.container), R.attr.colorSurface)
+        )
+        transform.addTarget(R.id.container)
+        transform.duration = 300
+        return transform
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_lyrics)
+        ViewCompat.setTransitionName(container, "lyrics")
+        setStatusbarColorAuto()
+        setTaskDescriptionColorAuto()
+        setNavigationbarColorAuto()
+
+        setupWakelock()
+
+        toolbar.setBackgroundColor(surfaceColor())
+        ToolbarContentTintHelper.colorBackButton(toolbar)
+        setSupportActionBar(toolbar)
+
+        updateHelper = MusicProgressViewUpdateHelper(this, 500, 1000)
+        setupLyricsView()
+    }
+
+    private fun setupLyricsView() {
+        lyricsView.apply {
+            setCurrentColor(ThemeStore.accentColor(context))
+            setTimeTextColor(ThemeStore.accentColor(context))
+            setTimelineColor(ThemeStore.accentColor(context))
+            setTimelineTextColor(ThemeStore.accentColor(context))
+            setDraggable(true, LrcView.OnPlayClickListener {
+                MusicPlayerRemote.seekTo(it.toInt())
+                return@OnPlayClickListener true
+            })
+        }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        updateHelper.start()
+    }
+
+    override fun onPause() {
+        super.onPause()
+        updateHelper.stop()
+    }
+
+    override fun onUpdateProgressViews(progress: Int, total: Int) {
+        lyricsView.updateTime(progress.toLong())
+    }
+
+    private fun loadLRCLyrics() {
+        lyricsView.setLabel("Empty")
+        val song = MusicPlayerRemote.currentSong
+        if (LyricUtil.isLrcOriginalFileExist(song.data)) {
+            lyricsView.loadLrc(LyricUtil.getLocalLyricOriginalFile(song.data))
+        } else if (LyricUtil.isLrcFileExist(song.title, song.artistName)) {
+            lyricsView.loadLrc(LyricUtil.getLocalLyricFile(song.title, song.artistName))
+        }
+    }
+
+    override fun onPlayingMetaChanged() {
+        super.onPlayingMetaChanged()
+        updateTitleSong()
+        loadLRCLyrics()
+    }
+
+    override fun onServiceConnected() {
+        super.onServiceConnected()
+        updateTitleSong()
+        loadLRCLyrics()
+    }
+
+    private fun updateTitleSong() {
+        song = MusicPlayerRemote.currentSong
+        toolbar.title = song.title
+        toolbar.subtitle = song.artistName
+    }
+
+    private fun setupWakelock() {
+        window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
+        menuInflater.inflate(R.menu.menu_search, menu)
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        if (item.itemId == android.R.id.home) {
+            finish()
+            return true
+        }
+        if (item.itemId == R.id.action_search) {
+            RetroUtil.openUrl(this, googleSearchLrcUrl)
+        }
+        return super.onOptionsItemSelected(item)
+    }
+}

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

@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities
+
+import android.content.Intent
+import android.content.SharedPreferences
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener
+import android.net.Uri
+import android.os.Bundle
+import android.provider.MediaStore
+import android.view.View
+import androidx.lifecycle.lifecycleScope
+import androidx.navigation.ui.NavigationUI
+import code.name.monkey.retromusic.ADAPTIVE_COLOR_APP
+import code.name.monkey.retromusic.ALBUM_COVER_STYLE
+import code.name.monkey.retromusic.ALBUM_COVER_TRANSFORM
+import code.name.monkey.retromusic.BANNER_IMAGE_PATH
+import code.name.monkey.retromusic.BLACK_THEME
+import code.name.monkey.retromusic.CAROUSEL_EFFECT
+import code.name.monkey.retromusic.CIRCULAR_ALBUM_ART
+import code.name.monkey.retromusic.DESATURATED_COLOR
+import code.name.monkey.retromusic.EXTRA_SONG_INFO
+import code.name.monkey.retromusic.GENERAL_THEME
+import code.name.monkey.retromusic.HOME_ARTIST_GRID_STYLE
+import code.name.monkey.retromusic.KEEP_SCREEN_ON
+import code.name.monkey.retromusic.LANGUAGE_NAME
+import code.name.monkey.retromusic.LIBRARY_CATEGORIES
+import code.name.monkey.retromusic.NOW_PLAYING_SCREEN_ID
+import code.name.monkey.retromusic.PROFILE_IMAGE_PATH
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.ROUND_CORNERS
+import code.name.monkey.retromusic.TAB_TEXT_MODE
+import code.name.monkey.retromusic.TOGGLE_ADD_CONTROLS
+import code.name.monkey.retromusic.TOGGLE_FULL_SCREEN
+import code.name.monkey.retromusic.TOGGLE_GENRE
+import code.name.monkey.retromusic.TOGGLE_HOME_BANNER
+import code.name.monkey.retromusic.TOGGLE_SEPARATE_LINE
+import code.name.monkey.retromusic.TOGGLE_VOLUME
+import code.name.monkey.retromusic.USER_NAME
+import code.name.monkey.retromusic.activities.base.AbsSlidingMusicPanelActivity
+import code.name.monkey.retromusic.extensions.extra
+import code.name.monkey.retromusic.extensions.findNavController
+import code.name.monkey.retromusic.helper.MusicPlayerRemote
+import code.name.monkey.retromusic.helper.SearchQueryHelper.getSongs
+import code.name.monkey.retromusic.model.CategoryInfo
+import code.name.monkey.retromusic.model.Song
+import code.name.monkey.retromusic.repository.PlaylistSongsLoader
+import code.name.monkey.retromusic.service.MusicService
+import code.name.monkey.retromusic.util.PreferenceUtil
+import kotlinx.coroutines.Dispatchers.IO
+import kotlinx.coroutines.launch
+import org.koin.android.ext.android.get
+
+class MainActivity : AbsSlidingMusicPanelActivity(), OnSharedPreferenceChangeListener {
+    companion object {
+        const val TAG = "MainActivity"
+        const val EXPAND_PANEL = "expand_panel"
+    }
+
+    override fun createContentView(): View {
+        return wrapSlidingMusicPanel()
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setLightNavigationBar(true)
+        setTaskDescriptionColorAuto()
+        hideStatusBar()
+        updateTabs()
+
+        setupNavigationController()
+        if (!hasPermissions()) {
+            findNavController(R.id.fragment_container).navigate(R.id.permissionFragment)
+        }
+    }
+
+    private fun setupNavigationController() {
+        val navController = findNavController(R.id.fragment_container)
+        val navInflater = navController.navInflater
+        val navGraph = navInflater.inflate(R.navigation.main_graph)
+
+        val categoryInfo: CategoryInfo = PreferenceUtil.libraryCategory.first { it.visible }
+        if (categoryInfo.visible) {
+            navGraph.startDestination = categoryInfo.category.id
+        }
+        navController.graph = navGraph
+        NavigationUI.setupWithNavController(getBottomNavigationView(), navController)
+    }
+
+    override fun onSupportNavigateUp(): Boolean =
+        findNavController(R.id.fragment_container).navigateUp()
+
+    override fun onResume() {
+        super.onResume()
+        PreferenceUtil.registerOnSharedPreferenceChangedListener(this)
+        val expand = extra<Boolean>(EXPAND_PANEL).value ?: false
+        if (expand && PreferenceUtil.isExpandPanel) {
+            expandPanel()
+            intent.removeExtra(EXPAND_PANEL)
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        PreferenceUtil.unregisterOnSharedPreferenceChangedListener(this)
+    }
+
+    override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences?, key: String?) {
+        if (key == GENERAL_THEME || key == BLACK_THEME || key == ADAPTIVE_COLOR_APP || key == USER_NAME || key == TOGGLE_FULL_SCREEN || key == TOGGLE_VOLUME || key == ROUND_CORNERS || key == CAROUSEL_EFFECT || key == NOW_PLAYING_SCREEN_ID || key == TOGGLE_GENRE || key == BANNER_IMAGE_PATH || key == PROFILE_IMAGE_PATH || key == CIRCULAR_ALBUM_ART || key == KEEP_SCREEN_ON || key == TOGGLE_SEPARATE_LINE || key == TOGGLE_HOME_BANNER || key == TOGGLE_ADD_CONTROLS || key == ALBUM_COVER_STYLE || key == HOME_ARTIST_GRID_STYLE || key == ALBUM_COVER_TRANSFORM || key == DESATURATED_COLOR || key == EXTRA_SONG_INFO || key == TAB_TEXT_MODE || key == LANGUAGE_NAME || key == LIBRARY_CATEGORIES) {
+            postRecreate()
+        }
+    }
+
+    override fun onServiceConnected() {
+        super.onServiceConnected()
+        intent ?: return
+        handlePlaybackIntent(intent)
+    }
+
+    private fun handlePlaybackIntent(intent: Intent) {
+        lifecycleScope.launch(IO) {
+            val uri: Uri? = intent.data
+            val mimeType: String? = intent.type
+            var handled = false
+            if (intent.action != null &&
+                intent.action == MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH
+            ) {
+                val songs: List<Song> = getSongs(intent.extras!!)
+                if (MusicPlayerRemote.shuffleMode == MusicService.SHUFFLE_MODE_SHUFFLE) {
+                    MusicPlayerRemote.openAndShuffleQueue(songs, true)
+                } else {
+                    MusicPlayerRemote.openQueue(songs, 0, true)
+                }
+                handled = true
+            }
+            if (uri != null && uri.toString().isNotEmpty()) {
+                MusicPlayerRemote.playFromUri(uri)
+                handled = true
+            } else if (MediaStore.Audio.Playlists.CONTENT_TYPE == mimeType) {
+                val id = parseLongFromIntent(intent, "playlistId", "playlist")
+                if (id >= 0L) {
+                    val position: Int = intent.getIntExtra("position", 0)
+                    val songs: List<Song> = PlaylistSongsLoader.getPlaylistSongList(get(), id)
+                    MusicPlayerRemote.openQueue(songs, position, true)
+                    handled = true
+                }
+            } else if (MediaStore.Audio.Albums.CONTENT_TYPE == mimeType) {
+                val id = parseLongFromIntent(intent, "albumId", "album")
+                if (id >= 0L) {
+                    val position: Int = intent.getIntExtra("position", 0)
+                    val songs = libraryViewModel.albumById(id).songs
+                    MusicPlayerRemote.openQueue(
+                        songs,
+                        position,
+                        true
+                    )
+                    handled = true
+                }
+            } else if (MediaStore.Audio.Artists.CONTENT_TYPE == mimeType) {
+                val id = parseLongFromIntent(intent, "artistId", "artist")
+                if (id >= 0L) {
+                    val position: Int = intent.getIntExtra("position", 0)
+                    val songs: List<Song> = libraryViewModel.artistById(id).songs
+                    MusicPlayerRemote.openQueue(
+                        songs,
+                        position,
+                        true
+                    )
+                    handled = true
+                }
+            }
+            if (handled) {
+                setIntent(Intent())
+            }
+        }
+    }
+
+    private fun parseLongFromIntent(
+        intent: Intent,
+        longKey: String,
+        stringKey: String
+    ): Long {
+        var id = intent.getLongExtra(longKey, -1)
+        if (id < 0) {
+            val idString = intent.getStringExtra(stringKey)
+            if (idString != null) {
+                try {
+                    id = idString.toLong()
+                } catch (e: NumberFormatException) {
+                    println(e.message)
+                }
+            }
+        }
+        return id
+    }
+}

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

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities
+
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import android.provider.Settings
+import androidx.core.text.HtmlCompat
+import code.name.monkey.appthemehelper.util.VersionUtils
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.base.AbsMusicServiceActivity
+import code.name.monkey.retromusic.extensions.accentBackgroundColor
+import code.name.monkey.retromusic.extensions.show
+import code.name.monkey.retromusic.util.RingtoneManager
+import kotlinx.android.synthetic.main.activity_permission.*
+
+class PermissionActivity : AbsMusicServiceActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView((R.layout.activity_permission))
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setLightNavigationBar(true)
+        setTaskDescriptionColorAuto()
+        setupTitle()
+
+        storagePermission.setButtonClick {
+            requestPermissions()
+        }
+        if (VersionUtils.hasMarshmallow()) audioPermission.show()
+        audioPermission.setButtonClick {
+            if (RingtoneManager.requiresDialog(this@PermissionActivity)) {
+                val intent = Intent(Settings.ACTION_MANAGE_WRITE_SETTINGS)
+                intent.data = Uri.parse("package:" + applicationContext.packageName)
+                startActivity(intent)
+            }
+        }
+        finish.accentBackgroundColor()
+        finish.setOnClickListener {
+            if (hasPermissions()) {
+                startActivity(
+                    Intent(this, MainActivity::class.java).addFlags(
+                        Intent.FLAG_ACTIVITY_NEW_TASK or
+                                Intent.FLAG_ACTIVITY_CLEAR_TASK
+                    )
+                )
+                finish()
+            }
+        }
+    }
+
+    private fun setupTitle() {
+        val appName = HtmlCompat.fromHtml(
+            "Hello there! <br>Welcome to <b>Metro</b>",
+            HtmlCompat.FROM_HTML_MODE_COMPACT
+        )
+        appNameText.text = appName
+    }
+}

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

@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities
+
+import android.content.res.ColorStateList
+import android.os.Bundle
+import android.view.MenuItem
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import code.name.monkey.appthemehelper.util.ColorUtil
+import code.name.monkey.appthemehelper.util.MaterialValueHelper
+import com.h6ah4i.android.widget.advrecyclerview.animator.DraggableItemAnimator
+import com.h6ah4i.android.widget.advrecyclerview.draggable.RecyclerViewDragDropManager
+import com.h6ah4i.android.widget.advrecyclerview.swipeable.RecyclerViewSwipeManager
+import com.h6ah4i.android.widget.advrecyclerview.touchguard.RecyclerViewTouchActionGuardManager
+import com.h6ah4i.android.widget.advrecyclerview.utils.WrapperAdapterUtils
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.base.AbsMusicServiceActivity
+import code.name.monkey.retromusic.adapter.song.PlayingQueueAdapter
+import code.name.monkey.retromusic.extensions.accentColor
+import code.name.monkey.retromusic.extensions.surfaceColor
+import code.name.monkey.retromusic.helper.MusicPlayerRemote
+import code.name.monkey.retromusic.util.MusicUtil
+import code.name.monkey.retromusic.util.ThemedFastScroller
+import kotlinx.android.synthetic.main.activity_playing_queue.*
+
+open class PlayingQueueActivity : AbsMusicServiceActivity() {
+
+    private var wrappedAdapter: RecyclerView.Adapter<*>? = null
+    private var recyclerViewDragDropManager: RecyclerViewDragDropManager? = null
+    private var recyclerViewSwipeManager: RecyclerViewSwipeManager? = null
+    private var recyclerViewTouchActionGuardManager: RecyclerViewTouchActionGuardManager? = null
+    private var playingQueueAdapter: PlayingQueueAdapter? = null
+    private lateinit var linearLayoutManager: LinearLayoutManager
+
+    private fun getUpNextAndQueueTime(): String {
+        val duration = MusicPlayerRemote.getQueueDurationMillis(MusicPlayerRemote.position)
+        return MusicUtil.buildInfoString(
+            resources.getString(R.string.up_next),
+            MusicUtil.getReadableDurationString(duration)
+        )
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_playing_queue)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setTaskDescriptionColorAuto()
+        setLightNavigationBar(true)
+
+        setupToolbar()
+        setUpRecyclerView()
+
+        clearQueue.setOnClickListener {
+            MusicPlayerRemote.clearQueue()
+        }
+        checkForPadding()
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        return when (item.itemId) {
+            android.R.id.home -> {
+                onBackPressed()
+                true
+            }
+            else -> super.onOptionsItemSelected(item)
+        }
+    }
+
+    private fun setUpRecyclerView() {
+        recyclerViewTouchActionGuardManager = RecyclerViewTouchActionGuardManager()
+        recyclerViewDragDropManager = RecyclerViewDragDropManager()
+        recyclerViewSwipeManager = RecyclerViewSwipeManager()
+
+        val animator = DraggableItemAnimator()
+        animator.supportsChangeAnimations = false
+
+        playingQueueAdapter = PlayingQueueAdapter(
+            this,
+            MusicPlayerRemote.playingQueue.toMutableList(),
+            MusicPlayerRemote.position,
+            R.layout.item_queue
+        )
+        wrappedAdapter = recyclerViewDragDropManager?.createWrappedAdapter(playingQueueAdapter!!)
+        wrappedAdapter = wrappedAdapter?.let { recyclerViewSwipeManager?.createWrappedAdapter(it) }
+
+        linearLayoutManager = LinearLayoutManager(this)
+
+        recyclerView.layoutManager = linearLayoutManager
+        recyclerView.adapter = wrappedAdapter
+        recyclerView.itemAnimator = animator
+        recyclerViewTouchActionGuardManager?.attachRecyclerView(recyclerView)
+        recyclerViewDragDropManager?.attachRecyclerView(recyclerView)
+        recyclerViewSwipeManager?.attachRecyclerView(recyclerView)
+        linearLayoutManager.scrollToPositionWithOffset(MusicPlayerRemote.position + 1, 0)
+
+        recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
+            override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+                super.onScrolled(recyclerView, dx, dy)
+                if (dy > 0) {
+                    clearQueue.shrink()
+                } else if (dy < 0) {
+                    clearQueue.extend()
+                }
+            }
+        })
+        ThemedFastScroller.create(recyclerView)
+    }
+
+    private fun checkForPadding() {
+    }
+
+    override fun onQueueChanged() {
+        if (MusicPlayerRemote.playingQueue.isEmpty()) {
+            finish()
+            return
+        }
+        checkForPadding()
+        updateQueue()
+        updateCurrentSong()
+    }
+
+    override fun onMediaStoreChanged() {
+        updateQueue()
+        updateCurrentSong()
+    }
+
+    private fun updateCurrentSong() {
+        toolbar.subtitle = getUpNextAndQueueTime()
+    }
+
+    override fun onPlayingMetaChanged() {
+        updateQueuePosition()
+    }
+
+    private fun updateQueuePosition() {
+        playingQueueAdapter?.setCurrent(MusicPlayerRemote.position)
+        resetToCurrentPosition()
+        toolbar.subtitle = getUpNextAndQueueTime()
+    }
+
+    private fun updateQueue() {
+        playingQueueAdapter?.swapDataSet(MusicPlayerRemote.playingQueue, MusicPlayerRemote.position)
+        resetToCurrentPosition()
+    }
+
+    private fun resetToCurrentPosition() {
+        recyclerView.stopScroll()
+        linearLayoutManager.scrollToPositionWithOffset(MusicPlayerRemote.position + 1, 0)
+    }
+
+    override fun onPause() {
+        if (recyclerViewDragDropManager != null) {
+            recyclerViewDragDropManager!!.cancelDrag()
+        }
+        super.onPause()
+    }
+
+    override fun onDestroy() {
+        if (recyclerViewDragDropManager != null) {
+            recyclerViewDragDropManager!!.release()
+            recyclerViewDragDropManager = null
+        }
+        if (recyclerViewSwipeManager != null) {
+            recyclerViewSwipeManager?.release()
+            recyclerViewSwipeManager = null
+        }
+        if (wrappedAdapter != null) {
+            WrapperAdapterUtils.releaseAll(wrappedAdapter)
+            wrappedAdapter = null
+        }
+        playingQueueAdapter = null
+        super.onDestroy()
+    }
+
+    private fun setupToolbar() {
+        toolbar.subtitle = getUpNextAndQueueTime()
+        toolbar.setBackgroundColor(surfaceColor())
+        setSupportActionBar(toolbar)
+        clearQueue.backgroundTintList = ColorStateList.valueOf(accentColor())
+        ColorStateList.valueOf(
+            MaterialValueHelper.getPrimaryTextColor(this, ColorUtil.isColorLight(accentColor()))
+        ).apply {
+            clearQueue.setTextColor(this)
+            clearQueue.iconTint = this
+        }
+    }
+}

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

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities
+
+import android.os.Bundle
+import android.view.MenuItem
+import androidx.navigation.NavController
+import androidx.navigation.NavDestination
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.appthemehelper.util.VersionUtils
+import com.afollestad.materialdialogs.color.ColorChooserDialog
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.base.AbsBaseActivity
+import code.name.monkey.retromusic.appshortcuts.DynamicShortcutManager
+import code.name.monkey.retromusic.extensions.applyToolbar
+import code.name.monkey.retromusic.extensions.findNavController
+import kotlinx.android.synthetic.main.activity_settings.*
+
+class SettingsActivity : AbsBaseActivity(), ColorChooserDialog.ColorCallback {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_settings)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setLightNavigationBar(true)
+        setupToolbar()
+    }
+
+    private fun setupToolbar() {
+        setTitle(R.string.action_settings)
+        applyToolbar(toolbar)
+        val navController: NavController = findNavController(R.id.contentFrame)
+        navController.addOnDestinationChangedListener { _, _, _ ->
+            toolbar.title = navController.currentDestination?.let { getStringFromDestination(it) }
+        }
+    }
+
+    private fun getStringFromDestination(currentDestination: NavDestination): String {
+        val idRes = when (currentDestination.id) {
+            R.id.mainSettingsFragment -> R.string.action_settings
+            R.id.audioSettings -> R.string.pref_header_audio
+            R.id.imageSettingFragment -> R.string.pref_header_images
+            R.id.notificationSettingsFragment -> R.string.notification
+            R.id.nowPlayingSettingsFragment -> R.string.now_playing
+            R.id.otherSettingsFragment -> R.string.others
+            R.id.personalizeSettingsFragment -> R.string.personalize
+            R.id.themeSettingsFragment -> R.string.general_settings_title
+            R.id.aboutActivity -> R.string.action_about
+            else -> R.id.action_settings
+        }
+        return getString(idRes)
+    }
+
+    override fun onSupportNavigateUp(): Boolean {
+        return findNavController(R.id.contentFrame).navigateUp() || super.onSupportNavigateUp()
+    }
+
+    override fun onColorSelection(dialog: ColorChooserDialog, selectedColor: Int) {
+        when (dialog.title) {
+            R.string.accent_color -> {
+                ThemeStore.editTheme(this).accentColor(selectedColor).commit()
+                if (VersionUtils.hasNougatMR())
+                    DynamicShortcutManager(this).updateDynamicShortcuts()
+            }
+        }
+        recreate()
+    }
+
+    override fun onColorChooserDismissed(dialog: ColorChooserDialog) {
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        if (item.itemId == android.R.id.home) {
+            onBackPressed()
+        }
+        return super.onOptionsItemSelected(item)
+    }
+}

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

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities
+
+import android.content.res.ColorStateList
+import android.graphics.Bitmap
+import android.graphics.Color
+import android.graphics.drawable.GradientDrawable
+import android.net.Uri
+import android.os.Bundle
+import android.provider.MediaStore.Images.Media
+import android.view.MenuItem
+import androidx.core.view.drawToBitmap
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.appthemehelper.util.ColorUtil
+import code.name.monkey.appthemehelper.util.MaterialValueHelper
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.base.AbsBaseActivity
+import code.name.monkey.retromusic.glide.RetroMusicColoredTarget
+import code.name.monkey.retromusic.glide.SongGlideRequest
+import code.name.monkey.retromusic.model.Song
+import code.name.monkey.retromusic.util.Share
+import code.name.monkey.retromusic.util.color.MediaNotificationProcessor
+import com.bumptech.glide.Glide
+import kotlinx.android.synthetic.main.activity_share_instagram.*
+
+/**
+ * Created by hemanths on 2020-02-02.
+ */
+
+class ShareInstagramStory : AbsBaseActivity() {
+
+    companion object {
+        const val EXTRA_SONG = "extra_song"
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        if (item.itemId == android.R.id.home) {
+            onBackPressed()
+            return true
+        }
+        return super.onOptionsItemSelected(item)
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_share_instagram)
+        setStatusbarColor(Color.TRANSPARENT)
+        setNavigationbarColor(Color.BLACK)
+
+        toolbar.setBackgroundColor(Color.TRANSPARENT)
+        setSupportActionBar(toolbar)
+
+        val song = intent.extras?.getParcelable<Song>(EXTRA_SONG)
+        song?.let { songFinal ->
+            SongGlideRequest.Builder.from(Glide.with(this), songFinal)
+                .checkIgnoreMediaStore(this@ShareInstagramStory)
+                .generatePalette(this@ShareInstagramStory)
+                .build()
+                .into(object : RetroMusicColoredTarget(image) {
+                    override fun onColorReady(colors: MediaNotificationProcessor) {
+                        val isColorLight = ColorUtil.isColorLight(colors.backgroundColor)
+                        setColors(isColorLight, colors.backgroundColor)
+                    }
+                })
+
+            shareTitle.text = songFinal.title
+            shareText.text = songFinal.artistName
+            shareButton.setOnClickListener {
+                val path: String = Media.insertImage(
+                    contentResolver,
+                    mainContent.drawToBitmap(Bitmap.Config.ARGB_8888),
+                    "Design", null
+                )
+                val uri = Uri.parse(path)
+                Share.shareStoryToSocial(
+                    this@ShareInstagramStory,
+                    uri
+                )
+            }
+        }
+        shareButton.setTextColor(
+            MaterialValueHelper.getPrimaryTextColor(
+                this,
+                ColorUtil.isColorLight(ThemeStore.accentColor(this))
+            )
+        )
+        shareButton.backgroundTintList = ColorStateList.valueOf(ThemeStore.accentColor(this))
+    }
+
+    private fun setColors(colorLight: Boolean, color: Int) {
+        setLightStatusbar(colorLight)
+        toolbar.setTitleTextColor(
+            MaterialValueHelper.getPrimaryTextColor(
+                this@ShareInstagramStory,
+                colorLight
+            )
+        )
+        toolbar.navigationIcon?.setTintList(
+            ColorStateList.valueOf(
+                MaterialValueHelper.getPrimaryTextColor(
+                    this@ShareInstagramStory,
+                    colorLight
+                )
+            )
+        )
+        mainContent.background =
+            GradientDrawable(
+                GradientDrawable.Orientation.TOP_BOTTOM,
+                intArrayOf(color, Color.BLACK)
+            )
+    }
+}

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

@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities
+
+import android.app.Activity
+import android.content.Intent
+import android.content.res.ColorStateList
+import android.graphics.Bitmap
+import android.net.Uri
+import android.os.Bundle
+import android.text.TextUtils
+import android.view.MenuItem
+import android.widget.Toast
+import code.name.monkey.appthemehelper.util.ColorUtil
+import code.name.monkey.appthemehelper.util.MaterialValueHelper
+import code.name.monkey.retromusic.Constants.USER_BANNER
+import code.name.monkey.retromusic.Constants.USER_PROFILE
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.base.AbsBaseActivity
+import code.name.monkey.retromusic.extensions.accentColor
+import code.name.monkey.retromusic.extensions.applyToolbar
+import code.name.monkey.retromusic.glide.ProfileBannerGlideRequest
+import code.name.monkey.retromusic.glide.UserProfileGlideRequest
+import code.name.monkey.retromusic.util.ImageUtil
+import code.name.monkey.retromusic.util.PreferenceUtil
+import com.bumptech.glide.Glide
+import com.bumptech.glide.load.engine.DiskCacheStrategy
+import com.bumptech.glide.request.RequestListener
+import com.bumptech.glide.request.target.Target
+import com.github.dhaval2404.imagepicker.ImagePicker
+import com.github.dhaval2404.imagepicker.constant.ImageProvider
+import java.io.BufferedOutputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import kotlinx.android.synthetic.main.activity_user_info.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+class UserInfoActivity : AbsBaseActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_user_info)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setTaskDescriptionColorAuto()
+        setLightNavigationBar(true)
+        applyToolbar(toolbar)
+
+        nameContainer.accentColor()
+        name.setText(PreferenceUtil.userName)
+
+        userImage.setOnClickListener {
+            pickNewPhoto()
+        }
+
+        bannerImage.setOnClickListener {
+            selectBannerImage()
+        }
+
+        next.setOnClickListener {
+            val nameString = name.text.toString().trim { it <= ' ' }
+            if (TextUtils.isEmpty(nameString)) {
+                Toast.makeText(this, "Umm you're name can't be empty!", Toast.LENGTH_SHORT).show()
+                return@setOnClickListener
+            }
+            PreferenceUtil.userName = nameString
+            setResult(Activity.RESULT_OK)
+            finish()
+        }
+
+        val textColor =
+            MaterialValueHelper.getPrimaryTextColor(this, ColorUtil.isColorLight(accentColor()))
+        next.backgroundTintList = ColorStateList.valueOf(accentColor())
+        next.iconTint = ColorStateList.valueOf(textColor)
+        next.setTextColor(textColor)
+        loadProfile()
+    }
+
+    private fun loadProfile() {
+        bannerImage?.let {
+            ProfileBannerGlideRequest.Builder.from(
+                Glide.with(this),
+                ProfileBannerGlideRequest.getBannerModel()
+            ).build().into(it)
+        }
+        UserProfileGlideRequest.Builder.from(
+            Glide.with(this),
+            UserProfileGlideRequest.getUserModel()
+        ).build().into(userImage)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        if (item.itemId == android.R.id.home) {
+            onBackPressed()
+        }
+        return super.onOptionsItemSelected(item)
+    }
+
+    private fun selectBannerImage() {
+        ImagePicker.with(this)
+            .compress(1440)
+            .provider(ImageProvider.GALLERY)
+            .crop(16f, 9f)
+            .start(PICK_BANNER_REQUEST)
+    }
+
+    private fun pickNewPhoto() {
+        ImagePicker.with(this)
+            .provider(ImageProvider.GALLERY)
+            .cropSquare()
+            .compress(1440)
+            .start(PICK_IMAGE_REQUEST)
+    }
+
+    public override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        super.onActivityResult(requestCode, resultCode, data)
+        if (resultCode == Activity.RESULT_OK && requestCode == PICK_IMAGE_REQUEST) {
+            val fileUri = data?.data
+            fileUri?.let { setAndSaveUserImage(it) }
+        } else if (resultCode == Activity.RESULT_OK && requestCode == PICK_BANNER_REQUEST) {
+            val fileUri = data?.data
+            fileUri?.let { setAndSaveBannerImage(it) }
+        } else if (resultCode == ImagePicker.RESULT_ERROR) {
+            Toast.makeText(this, ImagePicker.getError(data), Toast.LENGTH_SHORT).show()
+        } else {
+            Toast.makeText(this, "Task Cancelled", Toast.LENGTH_SHORT).show()
+        }
+    }
+
+    private fun setAndSaveBannerImage(fileUri: Uri) {
+        Glide.with(this)
+            .load(fileUri)
+            .asBitmap()
+            .diskCacheStrategy(DiskCacheStrategy.NONE)
+            .listener(object : RequestListener<Any, Bitmap> {
+                override fun onException(
+                    e: java.lang.Exception?,
+                    model: Any?,
+                    target: Target<Bitmap>?,
+                    isFirstResource: Boolean
+                ): Boolean {
+                    return false
+                }
+
+                override fun onResourceReady(
+                    resource: Bitmap?,
+                    model: Any?,
+                    target: Target<Bitmap>?,
+                    isFromMemoryCache: Boolean,
+                    isFirstResource: Boolean
+                ): Boolean {
+                    resource?.let { saveImage(it, USER_BANNER) }
+                    return false
+                }
+            })
+            .into(bannerImage)
+    }
+
+    private fun saveImage(bitmap: Bitmap, fileName: String) {
+        CoroutineScope(Dispatchers.IO).launch {
+            val appDir = applicationContext.filesDir
+            val file = File(appDir, fileName)
+            var successful = false
+            try {
+                val os = BufferedOutputStream(FileOutputStream(file))
+                successful = ImageUtil.resizeBitmap(bitmap, 2048)
+                    .compress(Bitmap.CompressFormat.WEBP, 100, os)
+                withContext(Dispatchers.IO) { os.close() }
+            } catch (e: IOException) {
+                e.printStackTrace()
+            }
+            if (successful) {
+                withContext(Dispatchers.Main) {
+                    Toast.makeText(this@UserInfoActivity, "Updated", Toast.LENGTH_SHORT).show()
+                }
+            }
+        }
+    }
+
+    private fun setAndSaveUserImage(fileUri: Uri) {
+        Glide.with(this)
+            .load(fileUri)
+            .asBitmap()
+            .diskCacheStrategy(DiskCacheStrategy.NONE)
+            .listener(object : RequestListener<Any, Bitmap> {
+                override fun onException(
+                    e: java.lang.Exception?,
+                    model: Any?,
+                    target: Target<Bitmap>?,
+                    isFirstResource: Boolean
+                ): Boolean {
+                    return false
+                }
+
+                override fun onResourceReady(
+                    resource: Bitmap?,
+                    model: Any?,
+                    target: Target<Bitmap>?,
+                    isFromMemoryCache: Boolean,
+                    isFirstResource: Boolean
+                ): Boolean {
+                    resource?.let { saveImage(it, USER_PROFILE) }
+                    return false
+                }
+            })
+            .into(userImage)
+    }
+
+    companion object {
+        private const val PICK_IMAGE_REQUEST = 9002
+        private const val PICK_BANNER_REQUEST = 9004
+    }
+}

app/src/main/java/code/name/monkey/retromusic/activities/WhatsNewActivity.java

@@ -0,0 +1,111 @@
+package code.name.monkey.retromusic.activities;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.graphics.Color;
+import android.os.Bundle;
+import android.webkit.WebView;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.widget.Toolbar;
+import code.name.monkey.appthemehelper.ThemeStore;
+import code.name.monkey.appthemehelper.util.ATHUtil;
+import code.name.monkey.appthemehelper.util.ColorUtil;
+import code.name.monkey.appthemehelper.util.MaterialValueHelper;
+import code.name.monkey.appthemehelper.util.ToolbarContentTintHelper;
+import code.name.monkey.retromusic.R;
+import code.name.monkey.retromusic.activities.base.AbsBaseActivity;
+import code.name.monkey.retromusic.util.PreferenceUtil;
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.Locale;
+
+public class WhatsNewActivity extends AbsBaseActivity {
+
+  private static String colorToCSS(int color) {
+    return String.format(
+        Locale.getDefault(),
+        "rgba(%d, %d, %d, %d)",
+        Color.red(color),
+        Color.green(color),
+        Color.blue(color),
+        Color.alpha(color)); // on API 29, WebView doesn't load with hex colors
+  }
+
+  private static void setChangelogRead(@NonNull Context context) {
+    try {
+      PackageInfo pInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
+      int currentVersion = pInfo.versionCode;
+      PreferenceUtil.INSTANCE.setLastVersion(currentVersion);
+    } catch (PackageManager.NameNotFoundException e) {
+      e.printStackTrace();
+    }
+  }
+
+  @Override
+  protected void onCreate(@Nullable Bundle savedInstanceState) {
+    setDrawUnderStatusBar();
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.activity_whats_new);
+    setStatusbarColorAuto();
+    setNavigationbarColorAuto();
+    setTaskDescriptionColorAuto();
+
+    WebView webView = findViewById(R.id.webView);
+    Toolbar toolbar = findViewById(R.id.toolbar);
+    toolbar.setBackgroundColor(ATHUtil.INSTANCE.resolveColor(this, R.attr.colorSurface));
+    toolbar.setNavigationOnClickListener(v -> onBackPressed());
+    ToolbarContentTintHelper.colorBackButton(toolbar);
+
+    try {
+      StringBuilder buf = new StringBuilder();
+      InputStream json = getAssets().open("retro-changelog.html");
+      BufferedReader in = new BufferedReader(new InputStreamReader(json, StandardCharsets.UTF_8));
+      String str;
+      while ((str = in.readLine()) != null) {
+        buf.append(str);
+      }
+      in.close();
+
+      // Inject color values for WebView body background and links
+      final boolean isDark = ATHUtil.INSTANCE.isWindowBackgroundDark(this);
+      final int accentColor = ThemeStore.Companion.accentColor(this);
+      final String backgroundColor =
+          colorToCSS(
+              ATHUtil.INSTANCE.resolveColor(
+                  this, R.attr.colorSurface, Color.parseColor(isDark ? "#424242" : "#ffffff")));
+      final String contentColor = colorToCSS(Color.parseColor(isDark ? "#ffffff" : "#000000"));
+      final String textColor = colorToCSS(Color.parseColor(isDark ? "#60FFFFFF" : "#80000000"));
+      final String accentColorString = colorToCSS(ThemeStore.Companion.accentColor(this));
+      final String accentTextColor =
+          colorToCSS(
+              MaterialValueHelper.getPrimaryTextColor(
+                  this, ColorUtil.INSTANCE.isColorLight(accentColor)));
+      final String changeLog =
+          buf.toString()
+              .replace(
+                  "{style-placeholder}",
+                  String.format(
+                      "body { background-color: %s; color: %s; } li {color: %s;} .colorHeader {background-color: %s; color: %s;} .tag {color: %s;}",
+                      backgroundColor,
+                      contentColor,
+                      textColor,
+                      accentColorString,
+                      accentTextColor,
+                      accentColorString))
+              .replace("{link-color}", colorToCSS(ThemeStore.Companion.accentColor(this)))
+              .replace(
+                  "{link-color-active}",
+                  colorToCSS(
+                      ColorUtil.INSTANCE.lightenColor(ThemeStore.Companion.accentColor(this))));
+      webView.loadData(changeLog, "text/html", "UTF-8");
+    } catch (Throwable e) {
+      webView.loadData(
+          "<h1>Unable to load</h1><p>" + e.getLocalizedMessage() + "</p>", "text/html", "UTF-8");
+    }
+    setChangelogRead(this);
+  }
+}

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

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities.base
+
+import android.Manifest
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.media.AudioManager
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.provider.Settings
+import android.view.KeyEvent
+import android.view.View
+import androidx.core.app.ActivityCompat
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.retromusic.R
+import com.google.android.material.snackbar.Snackbar
+
+abstract class AbsBaseActivity : AbsThemeActivity() {
+    private var hadPermissions: Boolean = false
+    private lateinit var permissions: Array<String>
+    private var permissionDeniedMessage: String? = null
+
+    open fun getPermissionsToRequest(): Array<String> {
+        return arrayOf()
+    }
+
+    protected fun setPermissionDeniedMessage(message: String) {
+        permissionDeniedMessage = message
+    }
+
+    fun getPermissionDeniedMessage(): String {
+        return if (permissionDeniedMessage == null) getString(R.string.permissions_denied) else permissionDeniedMessage!!
+    }
+
+    private val snackBarContainer: View
+        get() = window.decorView
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        volumeControlStream = AudioManager.STREAM_MUSIC
+        permissions = getPermissionsToRequest()
+        hadPermissions = hasPermissions()
+        permissionDeniedMessage = null
+    }
+
+    override fun onPostCreate(savedInstanceState: Bundle?) {
+        super.onPostCreate(savedInstanceState)
+        if (!hasPermissions()) {
+            // requestPermissions()
+        }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        val hasPermissions = hasPermissions()
+        if (hasPermissions != hadPermissions) {
+            hadPermissions = hasPermissions
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                onHasPermissionsChanged(hasPermissions)
+            }
+        }
+    }
+
+    protected open fun onHasPermissionsChanged(hasPermissions: Boolean) {
+        // implemented by sub classes
+        println(hasPermissions)
+    }
+
+    override fun dispatchKeyEvent(event: KeyEvent): Boolean {
+        if (event.keyCode == KeyEvent.KEYCODE_MENU && event.action == KeyEvent.ACTION_UP) {
+            showOverflowMenu()
+            return true
+        }
+        return super.dispatchKeyEvent(event)
+    }
+
+    private fun showOverflowMenu() {
+    }
+
+    protected open fun requestPermissions() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            requestPermissions(permissions, PERMISSION_REQUEST)
+        }
+    }
+
+    protected fun hasPermissions(): Boolean {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            for (permission in permissions) {
+                if (checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) {
+                    return false
+                }
+            }
+        }
+        return true
+    }
+
+    override fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<String>,
+        grantResults: IntArray
+    ) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+        if (requestCode == PERMISSION_REQUEST) {
+            for (grantResult in grantResults) {
+                if (grantResult != PackageManager.PERMISSION_GRANTED) {
+                    if (ActivityCompat.shouldShowRequestPermissionRationale(
+                            this@AbsBaseActivity, Manifest.permission.WRITE_EXTERNAL_STORAGE
+                        )
+                    ) {
+                        // User has deny from permission dialog
+                        Snackbar.make(
+                            snackBarContainer,
+                            permissionDeniedMessage!!,
+                            Snackbar.LENGTH_INDEFINITE
+                        )
+                            .setAction(R.string.action_grant) { requestPermissions() }
+                            .setActionTextColor(ThemeStore.accentColor(this)).show()
+                    } else {
+                        // User has deny permission and checked never show permission dialog so you can redirect to Application settings page
+                        Snackbar.make(
+                            snackBarContainer,
+                            permissionDeniedMessage!!,
+                            Snackbar.LENGTH_INDEFINITE
+                        ).setAction(R.string.action_settings) {
+                            val intent = Intent()
+                            intent.action = Settings.ACTION_APPLICATION_DETAILS_SETTINGS
+                            val uri = Uri.fromParts(
+                                "package",
+                                this@AbsBaseActivity.packageName,
+                                null
+                            )
+                            intent.data = uri
+                            startActivity(intent)
+                        }.setActionTextColor(ThemeStore.accentColor(this)).show()
+                    }
+                    return
+                }
+            }
+            hadPermissions = true
+            onHasPermissionsChanged(true)
+        }
+    }
+
+    companion object {
+        const val PERMISSION_REQUEST = 100
+    }
+}

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

@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities.base
+
+import android.Manifest
+import android.content.BroadcastReceiver
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.ServiceConnection
+import android.os.Bundle
+import android.os.IBinder
+import androidx.lifecycle.lifecycleScope
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.db.toPlayCount
+import code.name.monkey.retromusic.helper.MusicPlayerRemote
+import code.name.monkey.retromusic.interfaces.IMusicServiceEventListener
+import code.name.monkey.retromusic.repository.RealRepository
+import code.name.monkey.retromusic.service.MusicService.*
+import java.lang.ref.WeakReference
+import java.util.*
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import org.koin.android.ext.android.inject
+
+abstract class AbsMusicServiceActivity : AbsBaseActivity(), IMusicServiceEventListener {
+
+    private val mMusicServiceEventListeners = ArrayList<IMusicServiceEventListener>()
+    private val repository: RealRepository by inject()
+    private var serviceToken: MusicPlayerRemote.ServiceToken? = null
+    private var musicStateReceiver: MusicStateReceiver? = null
+    private var receiverRegistered: Boolean = false
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        serviceToken = MusicPlayerRemote.bindToService(this, object : ServiceConnection {
+            override fun onServiceConnected(name: ComponentName, service: IBinder) {
+                this@AbsMusicServiceActivity.onServiceConnected()
+            }
+
+            override fun onServiceDisconnected(name: ComponentName) {
+                this@AbsMusicServiceActivity.onServiceDisconnected()
+            }
+        })
+
+        setPermissionDeniedMessage(getString(R.string.permission_external_storage_denied))
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        MusicPlayerRemote.unbindFromService(serviceToken)
+        if (receiverRegistered) {
+            unregisterReceiver(musicStateReceiver)
+            receiverRegistered = false
+        }
+    }
+
+    fun addMusicServiceEventListener(listenerI: IMusicServiceEventListener?) {
+        if (listenerI != null) {
+            mMusicServiceEventListeners.add(listenerI)
+        }
+    }
+
+    fun removeMusicServiceEventListener(listenerI: IMusicServiceEventListener?) {
+        if (listenerI != null) {
+            mMusicServiceEventListeners.remove(listenerI)
+        }
+    }
+
+    override fun onServiceConnected() {
+        if (!receiverRegistered) {
+            musicStateReceiver = MusicStateReceiver(this)
+
+            val filter = IntentFilter()
+            filter.addAction(PLAY_STATE_CHANGED)
+            filter.addAction(SHUFFLE_MODE_CHANGED)
+            filter.addAction(REPEAT_MODE_CHANGED)
+            filter.addAction(META_CHANGED)
+            filter.addAction(QUEUE_CHANGED)
+            filter.addAction(MEDIA_STORE_CHANGED)
+            filter.addAction(FAVORITE_STATE_CHANGED)
+
+            registerReceiver(musicStateReceiver, filter)
+
+            receiverRegistered = true
+        }
+
+        for (listener in mMusicServiceEventListeners) {
+            listener.onServiceConnected()
+        }
+    }
+
+    override fun onServiceDisconnected() {
+        if (receiverRegistered) {
+            unregisterReceiver(musicStateReceiver)
+            receiverRegistered = false
+        }
+
+        for (listener in mMusicServiceEventListeners) {
+            listener.onServiceDisconnected()
+        }
+    }
+
+    override fun onPlayingMetaChanged() {
+        for (listener in mMusicServiceEventListeners) {
+            listener.onPlayingMetaChanged()
+        }
+        lifecycleScope.launch(Dispatchers.IO) {
+            val entity = repository.songPresentInHistory(MusicPlayerRemote.currentSong)
+            if (entity != null) {
+                repository.updateHistorySong(MusicPlayerRemote.currentSong)
+            } else {
+                repository.addSongToHistory(MusicPlayerRemote.currentSong)
+            }
+            val songs = repository.checkSongExistInPlayCount(MusicPlayerRemote.currentSong.id)
+            if (songs.isNotEmpty()) {
+                repository.updateSongInPlayCount(songs.first().apply {
+                    playCount += 1
+                })
+            } else {
+                repository.insertSongInPlayCount(MusicPlayerRemote.currentSong.toPlayCount())
+            }
+        }
+    }
+
+    override fun onQueueChanged() {
+        for (listener in mMusicServiceEventListeners) {
+            listener.onQueueChanged()
+        }
+    }
+
+    override fun onPlayStateChanged() {
+        for (listener in mMusicServiceEventListeners) {
+            listener.onPlayStateChanged()
+        }
+    }
+
+    override fun onMediaStoreChanged() {
+        for (listener in mMusicServiceEventListeners) {
+            listener.onMediaStoreChanged()
+        }
+    }
+
+    override fun onRepeatModeChanged() {
+        for (listener in mMusicServiceEventListeners) {
+            listener.onRepeatModeChanged()
+        }
+    }
+
+    override fun onShuffleModeChanged() {
+        for (listener in mMusicServiceEventListeners) {
+            listener.onShuffleModeChanged()
+        }
+    }
+
+    override fun onHasPermissionsChanged(hasPermissions: Boolean) {
+        super.onHasPermissionsChanged(hasPermissions)
+        val intent = Intent(MEDIA_STORE_CHANGED)
+        intent.putExtra(
+            "from_permissions_changed",
+            true
+        ) // just in case we need to know this at some point
+        sendBroadcast(intent)
+        println("sendBroadcast $hasPermissions")
+    }
+
+    override fun getPermissionsToRequest(): Array<String> {
+        return arrayOf(
+            Manifest.permission.READ_EXTERNAL_STORAGE,
+            Manifest.permission.WRITE_EXTERNAL_STORAGE,
+            Manifest.permission.BLUETOOTH
+        )
+    }
+
+    private class MusicStateReceiver(activity: AbsMusicServiceActivity) : BroadcastReceiver() {
+
+        private val reference: WeakReference<AbsMusicServiceActivity> = WeakReference(activity)
+
+        override fun onReceive(context: Context, intent: Intent) {
+            val action = intent.action
+            val activity = reference.get()
+            if (activity != null && action != null) {
+                when (action) {
+                    FAVORITE_STATE_CHANGED, META_CHANGED -> activity.onPlayingMetaChanged()
+                    QUEUE_CHANGED -> activity.onQueueChanged()
+                    PLAY_STATE_CHANGED -> activity.onPlayStateChanged()
+                    REPEAT_MODE_CHANGED -> activity.onRepeatModeChanged()
+                    SHUFFLE_MODE_CHANGED -> activity.onShuffleModeChanged()
+                    MEDIA_STORE_CHANGED -> activity.onMediaStoreChanged()
+                }
+            }
+        }
+    }
+
+    companion object {
+        val TAG: String = AbsMusicServiceActivity::class.java.simpleName
+    }
+}

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

@@ -0,0 +1,390 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities.base
+
+import android.annotation.SuppressLint
+import android.graphics.Color
+import android.os.Bundle
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewTreeObserver
+import android.widget.FrameLayout
+import androidx.core.view.ViewCompat
+import androidx.core.view.isVisible
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.commit
+import code.name.monkey.appthemehelper.util.ATHUtil
+import code.name.monkey.appthemehelper.util.ColorUtil
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.RetroBottomSheetBehavior
+import code.name.monkey.retromusic.extensions.*
+import code.name.monkey.retromusic.fragments.LibraryViewModel
+import code.name.monkey.retromusic.fragments.MiniPlayerFragment
+import code.name.monkey.retromusic.fragments.NowPlayingScreen
+import code.name.monkey.retromusic.fragments.NowPlayingScreen.*
+import code.name.monkey.retromusic.fragments.base.AbsPlayerFragment
+import code.name.monkey.retromusic.fragments.player.adaptive.AdaptiveFragment
+import code.name.monkey.retromusic.fragments.player.blur.BlurPlayerFragment
+import code.name.monkey.retromusic.fragments.player.card.CardFragment
+import code.name.monkey.retromusic.fragments.player.cardblur.CardBlurFragment
+import code.name.monkey.retromusic.fragments.player.circle.CirclePlayerFragment
+import code.name.monkey.retromusic.fragments.player.classic.ClassicPlayerFragment
+import code.name.monkey.retromusic.fragments.player.color.ColorFragment
+import code.name.monkey.retromusic.fragments.player.fit.FitFragment
+import code.name.monkey.retromusic.fragments.player.flat.FlatPlayerFragment
+import code.name.monkey.retromusic.fragments.player.full.FullPlayerFragment
+import code.name.monkey.retromusic.fragments.player.gradient.GradientPlayerFragment
+import code.name.monkey.retromusic.fragments.player.material.MaterialFragment
+import code.name.monkey.retromusic.fragments.player.normal.PlayerFragment
+import code.name.monkey.retromusic.fragments.player.peak.PeakPlayerFragment
+import code.name.monkey.retromusic.fragments.player.plain.PlainPlayerFragment
+import code.name.monkey.retromusic.fragments.player.simple.SimplePlayerFragment
+import code.name.monkey.retromusic.fragments.player.tiny.TinyPlayerFragment
+import code.name.monkey.retromusic.helper.MusicPlayerRemote
+import code.name.monkey.retromusic.model.CategoryInfo
+import code.name.monkey.retromusic.util.PreferenceUtil
+import code.name.monkey.retromusic.views.BottomNavigationBarTinted
+import com.google.android.material.bottomsheet.BottomSheetBehavior.*
+import kotlinx.android.synthetic.main.sliding_music_panel_layout.*
+import org.koin.androidx.viewmodel.ext.android.viewModel
+
+abstract class AbsSlidingMusicPanelActivity : AbsMusicServiceActivity() {
+    companion object {
+        val TAG: String = AbsSlidingMusicPanelActivity::class.java.simpleName
+    }
+
+    protected val libraryViewModel by viewModel<LibraryViewModel>()
+    private lateinit var bottomSheetBehavior: RetroBottomSheetBehavior<FrameLayout>
+    private var playerFragment: AbsPlayerFragment? = null
+    private var miniPlayerFragment: MiniPlayerFragment? = null
+    private var nowPlayingScreen: NowPlayingScreen? = null
+    private var navigationBarColor: Int = 0
+    private var taskColor: Int = 0
+    private var lightStatusBar: Boolean = false
+    private var lightNavigationBar: Boolean = false
+    private var paletteColor: Int = Color.WHITE
+    protected abstract fun createContentView(): View
+    private val panelState: Int
+        get() = bottomSheetBehavior.state
+
+    private val bottomSheetCallbackList = object : BottomSheetCallback() {
+
+        override fun onSlide(bottomSheet: View, slideOffset: Float) {
+            setMiniPlayerAlphaProgress(slideOffset)
+            dimBackground.show()
+            dimBackground.alpha = slideOffset
+        }
+
+        override fun onStateChanged(bottomSheet: View, newState: Int) {
+            when (newState) {
+                STATE_EXPANDED -> {
+                    onPanelExpanded()
+                }
+                STATE_COLLAPSED -> {
+                    onPanelCollapsed()
+                    dimBackground.hide()
+                }
+
+                else -> {
+                    println("Do something")
+                }
+            }
+        }
+    }
+
+    fun getBottomSheetBehavior() = bottomSheetBehavior
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(createContentView())
+        chooseFragmentForTheme()
+        setupSlidingUpPanel()
+        setupBottomSheet()
+        updateColor()
+
+        val themeColor = resolveColor(android.R.attr.windowBackground, Color.GRAY)
+        dimBackground.setBackgroundColor(ColorUtil.withAlpha(themeColor, 0.5f))
+        dimBackground.setOnClickListener {
+            println("dimBackground")
+            collapsePanel()
+        }
+    }
+
+    private fun setupBottomSheet() {
+        bottomSheetBehavior = from(slidingPanel) as RetroBottomSheetBehavior
+        bottomSheetBehavior.addBottomSheetCallback(bottomSheetCallbackList)
+    }
+
+    override fun onResume() {
+        super.onResume()
+        if (nowPlayingScreen != PreferenceUtil.nowPlayingScreen) {
+            postRecreate()
+        }
+        if (bottomSheetBehavior.state == STATE_EXPANDED) {
+            setMiniPlayerAlphaProgress(1f)
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        bottomSheetBehavior.removeBottomSheetCallback(bottomSheetCallbackList)
+    }
+
+    @SuppressLint("InflateParams")
+    protected fun wrapSlidingMusicPanel(): View {
+        val slidingMusicPanelLayout =
+            layoutInflater.inflate(R.layout.sliding_music_panel_layout, null)
+        val contentContainer: ViewGroup =
+            slidingMusicPanelLayout.findViewById(R.id.mainContentFrame)
+        layoutInflater.inflate(R.layout.activity_main_content, contentContainer)
+        return slidingMusicPanelLayout
+    }
+
+    fun collapsePanel() {
+        bottomSheetBehavior.state = STATE_COLLAPSED
+        setMiniPlayerAlphaProgress(0f)
+    }
+
+    fun expandPanel() {
+        bottomSheetBehavior.state = STATE_EXPANDED
+        setMiniPlayerAlphaProgress(1f)
+    }
+
+    private fun setMiniPlayerAlphaProgress(progress: Float) {
+        val alpha = 1 - progress
+        miniPlayerFragment?.view?.alpha = alpha
+        miniPlayerFragment?.view?.visibility = if (alpha == 0f) View.GONE else View.VISIBLE
+        bottomNavigationView.translationY = progress * 500
+        bottomNavigationView.alpha = alpha
+    }
+
+    open fun onPanelCollapsed() {
+        // restore values
+        super.setLightStatusbar(lightStatusBar)
+        super.setTaskDescriptionColor(taskColor)
+        super.setNavigationbarColor(navigationBarColor)
+        super.setLightNavigationBar(lightNavigationBar)
+    }
+
+    open fun onPanelExpanded() {
+        onPaletteColorChanged()
+    }
+
+    private fun setupSlidingUpPanel() {
+        slidingPanel.viewTreeObserver.addOnGlobalLayoutListener(object :
+            ViewTreeObserver.OnGlobalLayoutListener {
+            override fun onGlobalLayout() {
+                slidingPanel.viewTreeObserver.removeOnGlobalLayoutListener(this)
+                if (nowPlayingScreen != Peak) {
+                    val params = slidingPanel.layoutParams as ViewGroup.LayoutParams
+                    params.height = ViewGroup.LayoutParams.MATCH_PARENT
+                    slidingPanel.layoutParams = params
+                }
+                when (panelState) {
+                    STATE_EXPANDED -> onPanelExpanded()
+                    STATE_COLLAPSED -> onPanelCollapsed()
+                    else -> {
+                        // playerFragment!!.onHide()
+                    }
+                }
+            }
+        })
+    }
+
+    fun getBottomNavigationView(): BottomNavigationBarTinted {
+        return bottomNavigationView
+    }
+
+    override fun onServiceConnected() {
+        super.onServiceConnected()
+        if (MusicPlayerRemote.playingQueue.isNotEmpty()) {
+            slidingPanel.viewTreeObserver.addOnGlobalLayoutListener(object :
+                ViewTreeObserver.OnGlobalLayoutListener {
+                override fun onGlobalLayout() {
+                    slidingPanel.viewTreeObserver.removeOnGlobalLayoutListener(this)
+                    hideBottomBar(false)
+                }
+            })
+        } // don't call hideBottomBar(true) here as it causes a bug with the SlidingUpPanelLayout
+    }
+
+    override fun onQueueChanged() {
+        super.onQueueChanged()
+        hideBottomBar(MusicPlayerRemote.playingQueue.isEmpty())
+    }
+
+    override fun onBackPressed() {
+        if (!handleBackPress()) super.onBackPressed()
+    }
+
+    private fun handleBackPress(): Boolean {
+        if (bottomSheetBehavior.peekHeight != 0 && playerFragment!!.onBackPressed()) return true
+        if (panelState == STATE_EXPANDED) {
+            collapsePanel()
+            return true
+        }
+
+        return false
+    }
+
+    private fun onPaletteColorChanged() {
+        if (panelState == STATE_EXPANDED) {
+            super.setTaskDescriptionColor(paletteColor)
+            val isColorLight = ColorUtil.isColorLight(paletteColor)
+            if (PreferenceUtil.isAdaptiveColor && (nowPlayingScreen == Normal || nowPlayingScreen == Flat)) {
+                super.setLightNavigationBar(true)
+                super.setLightStatusbar(isColorLight)
+            } else if (nowPlayingScreen == Card || nowPlayingScreen == Blur || nowPlayingScreen == BlurCard) {
+                super.setLightStatusbar(false)
+                super.setLightNavigationBar(true)
+                super.setNavigationbarColor(Color.BLACK)
+            } else if (nowPlayingScreen == Color || nowPlayingScreen == Tiny || nowPlayingScreen == Gradient) {
+                super.setNavigationbarColor(paletteColor)
+                super.setLightNavigationBar(isColorLight)
+                super.setLightStatusbar(isColorLight)
+            } else if (nowPlayingScreen == Full) {
+                super.setNavigationbarColor(paletteColor)
+                super.setLightNavigationBar(isColorLight)
+                super.setLightStatusbar(false)
+            } else if (nowPlayingScreen == Classic) {
+                super.setLightStatusbar(false)
+            } else if (nowPlayingScreen == Fit) {
+                super.setLightStatusbar(false)
+            } else {
+                super.setLightStatusbar(
+                    ColorUtil.isColorLight(
+                        ATHUtil.resolveColor(
+                            this,
+                            android.R.attr.windowBackground
+                        )
+                    )
+                )
+                super.setLightNavigationBar(true)
+            }
+        }
+    }
+
+    override fun setLightStatusbar(enabled: Boolean) {
+        lightStatusBar = enabled
+        if (panelState == STATE_COLLAPSED) {
+            super.setLightStatusbar(enabled)
+        }
+    }
+
+    override fun setLightNavigationBar(enabled: Boolean) {
+        lightNavigationBar = enabled
+        if (panelState == STATE_COLLAPSED) {
+            super.setLightNavigationBar(enabled)
+        }
+    }
+
+    override fun setNavigationbarColor(color: Int) {
+        navigationBarColor = color
+        if (panelState == STATE_COLLAPSED) {
+            super.setNavigationbarColor(color)
+        }
+    }
+
+    override fun setTaskDescriptionColor(color: Int) {
+        taskColor = color
+        if (panelState == STATE_COLLAPSED) {
+            super.setTaskDescriptionColor(color)
+        }
+    }
+
+    fun updateTabs() {
+        bottomNavigationView.menu.clear()
+        val currentTabs: List<CategoryInfo> = PreferenceUtil.libraryCategory
+        for (tab in currentTabs) {
+            if (tab.visible) {
+                val menu = tab.category
+                bottomNavigationView.menu.add(0, menu.id, 0, menu.stringRes).setIcon(menu.icon)
+            }
+        }
+        if (bottomNavigationView.menu.size() == 1) {
+            bottomNavigationView.hide()
+        }
+    }
+
+    private fun updateColor() {
+        libraryViewModel.paletteColor.observe(this, { color ->
+            this.paletteColor = color
+            onPaletteColorChanged()
+        })
+    }
+
+    fun setBottomBarVisibility(visible: Boolean) {
+        bottomNavigationView.isVisible = visible
+        hideBottomBar(MusicPlayerRemote.playingQueue.isEmpty())
+    }
+
+    private fun hideBottomBar(hide: Boolean) {
+        val heightOfBar = dip(R.dimen.mini_player_height)
+        val heightOfBarWithTabs = heightOfBar * 2
+        val isVisible = bottomNavigationView.isVisible
+        if (hide) {
+            bottomSheetBehavior.isHideable = true
+            bottomSheetBehavior.peekHeight = 0
+            ViewCompat.setElevation(slidingPanel, 0f)
+            ViewCompat.setElevation(bottomNavigationView, 10f)
+            collapsePanel()
+        } else {
+            if (MusicPlayerRemote.playingQueue.isNotEmpty()) {
+                bottomSheetBehavior.isHideable = false
+                ViewCompat.setElevation(slidingPanel, 10f)
+                ViewCompat.setElevation(bottomNavigationView, 10f)
+                if (isVisible) {
+                    println("List")
+                    bottomSheetBehavior.peekHeight = heightOfBarWithTabs - 22
+                } else {
+                    println("Details")
+                    bottomSheetBehavior.peekHeight = heightOfBar
+                }
+            }
+        }
+    }
+
+    private fun chooseFragmentForTheme() {
+        nowPlayingScreen = PreferenceUtil.nowPlayingScreen
+
+        val fragment: Fragment = when (nowPlayingScreen) {
+            Blur -> BlurPlayerFragment()
+            Adaptive -> AdaptiveFragment()
+            Normal -> PlayerFragment()
+            Card -> CardFragment()
+            BlurCard -> CardBlurFragment()
+            Fit -> FitFragment()
+            Flat -> FlatPlayerFragment()
+            Full -> FullPlayerFragment()
+            Plain -> PlainPlayerFragment()
+            Simple -> SimplePlayerFragment()
+            Material -> MaterialFragment()
+            Color -> ColorFragment()
+            Gradient -> GradientPlayerFragment()
+            Tiny -> TinyPlayerFragment()
+            Peak -> PeakPlayerFragment()
+            Circle -> CirclePlayerFragment()
+            Classic -> ClassicPlayerFragment()
+            else -> PlayerFragment()
+        } // must implement AbsPlayerFragment
+        supportFragmentManager.commit {
+            replace(R.id.playerFragmentContainer, fragment)
+        }
+        supportFragmentManager.executePendingTransactions()
+        playerFragment = whichFragment<AbsPlayerFragment>(R.id.playerFragmentContainer)
+        miniPlayerFragment = whichFragment<MiniPlayerFragment>(R.id.miniPlayerFragment)
+        miniPlayerFragment?.view?.setOnClickListener { expandPanel() }
+    }
+}

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

@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities.base
+
+import android.content.Context
+import android.graphics.Color
+import android.os.Bundle
+import android.os.Handler
+import android.view.KeyEvent
+import android.view.View
+import android.view.WindowManager
+import androidx.annotation.ColorInt
+import androidx.appcompat.app.AppCompatDelegate.setDefaultNightMode
+import code.name.monkey.appthemehelper.ATH
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.appthemehelper.common.ATHToolbarActivity
+import code.name.monkey.appthemehelper.util.ATHUtil
+import code.name.monkey.appthemehelper.util.ColorUtil
+import code.name.monkey.appthemehelper.util.MaterialDialogsUtil
+import code.name.monkey.appthemehelper.util.VersionUtils
+import code.name.monkey.retromusic.LanguageContextWrapper
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.util.PreferenceUtil
+import code.name.monkey.retromusic.util.RetroUtil
+import code.name.monkey.retromusic.util.theme.ThemeManager
+import java.util.*
+
+abstract class AbsThemeActivity : ATHToolbarActivity(), Runnable {
+
+    private val handler = Handler()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        updateTheme()
+        hideStatusBar()
+        super.onCreate(savedInstanceState)
+        setImmersiveFullscreen()
+        registerSystemUiVisibility()
+        toggleScreenOn()
+        MaterialDialogsUtil.updateMaterialDialogsThemeSingleton(this)
+    }
+
+    private fun updateTheme() {
+        setTheme(ThemeManager.getThemeResValue(this))
+        setDefaultNightMode(ThemeManager.getNightMode(this))
+    }
+
+    private fun toggleScreenOn() {
+        if (PreferenceUtil.isScreenOnEnabled) {
+            window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        } else {
+            window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        }
+    }
+
+    override fun onWindowFocusChanged(hasFocus: Boolean) {
+        super.onWindowFocusChanged(hasFocus)
+        if (hasFocus) {
+            hideStatusBar()
+            handler.removeCallbacks(this)
+            handler.postDelayed(this, 300)
+        } else {
+            handler.removeCallbacks(this)
+        }
+    }
+
+    fun hideStatusBar() {
+        hideStatusBar(PreferenceUtil.isFullScreenMode)
+    }
+
+    private fun hideStatusBar(fullscreen: Boolean) {
+        val statusBar = window.decorView.rootView.findViewById<View>(R.id.status_bar)
+        if (statusBar != null) {
+            statusBar.visibility = if (fullscreen) View.GONE else View.VISIBLE
+        }
+    }
+
+    fun setDrawUnderStatusBar() {
+        RetroUtil.setAllowDrawUnderStatusBar(window)
+    }
+
+    fun setDrawUnderNavigationBar() {
+        RetroUtil.setAllowDrawUnderNavigationBar(window)
+    }
+
+    /**
+     * This will set the color of the view with the id "status_bar" on KitKat and Lollipop. On
+     * Lollipop if no such view is found it will set the statusbar color using the native method.
+     *
+     * @param color the new statusbar color (will be shifted down on Lollipop and above)
+     */
+    fun setStatusbarColor(color: Int) {
+        val statusBar = window.decorView.rootView.findViewById<View>(R.id.status_bar)
+        if (statusBar != null) {
+            when {
+                VersionUtils.hasMarshmallow() -> statusBar.setBackgroundColor(color)
+                VersionUtils.hasLollipop() -> statusBar.setBackgroundColor(
+                    ColorUtil.darkenColor(
+                        color
+                    )
+                )
+                else -> statusBar.setBackgroundColor(color)
+            }
+        } else {
+            when {
+                VersionUtils.hasMarshmallow() -> window.statusBarColor = color
+                else -> window.statusBarColor = ColorUtil.darkenColor(color)
+            }
+        }
+        setLightStatusbarAuto(ATHUtil.resolveColor(this, R.attr.colorSurface))
+    }
+
+    fun setStatusbarColorAuto() {
+        // we don't want to use statusbar color because we are doing the color darkening on our own to support KitKat
+        setStatusbarColor(ATHUtil.resolveColor(this, R.attr.colorSurface))
+        setLightStatusbarAuto(ATHUtil.resolveColor(this, R.attr.colorSurface))
+    }
+
+    open fun setTaskDescriptionColor(@ColorInt color: Int) {
+        ATH.setTaskDescriptionColor(this, color)
+    }
+
+    fun setTaskDescriptionColorAuto() {
+        setTaskDescriptionColor(ATHUtil.resolveColor(this, R.attr.colorSurface))
+    }
+
+    open fun setNavigationbarColor(color: Int) {
+        if (ThemeStore.coloredNavigationBar(this)) {
+            ATH.setNavigationbarColor(this, color)
+        } else {
+            ATH.setNavigationbarColor(this, Color.BLACK)
+        }
+    }
+
+    fun setNavigationbarColorAuto() {
+        setNavigationbarColor(ATHUtil.resolveColor(this, R.attr.colorSurface))
+    }
+
+    open fun setLightStatusbar(enabled: Boolean) {
+        ATH.setLightStatusbar(this, enabled)
+    }
+
+    fun setLightStatusbarAuto(bgColor: Int) {
+        setLightStatusbar(ColorUtil.isColorLight(bgColor))
+    }
+
+    open fun setLightNavigationBar(enabled: Boolean) {
+        if (!ATHUtil.isWindowBackgroundDark(this) and ThemeStore.coloredNavigationBar(this)) {
+            ATH.setLightNavigationbar(this, enabled)
+        }
+    }
+
+    private fun registerSystemUiVisibility() {
+        val decorView = window.decorView
+        decorView.setOnSystemUiVisibilityChangeListener { visibility ->
+            if (visibility and View.SYSTEM_UI_FLAG_FULLSCREEN == 0) {
+                setImmersiveFullscreen()
+            }
+        }
+    }
+
+    private fun unregisterSystemUiVisibility() {
+        val decorView = window.decorView
+        decorView.setOnSystemUiVisibilityChangeListener(null)
+    }
+
+    private fun setImmersiveFullscreen() {
+        val flags =
+            (View.SYSTEM_UI_FLAG_LAYOUT_STABLE or View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or View.SYSTEM_UI_FLAG_FULLSCREEN or View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY)
+
+        if (PreferenceUtil.isFullScreenMode) {
+            window.decorView.systemUiVisibility = flags
+        }
+    }
+
+    private fun exitFullscreen() {
+        window.decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_VISIBLE
+    }
+
+    override fun run() {
+        setImmersiveFullscreen()
+    }
+
+    override fun onStop() {
+        handler.removeCallbacks(this)
+        super.onStop()
+    }
+
+    public override fun onDestroy() {
+        super.onDestroy()
+        unregisterSystemUiVisibility()
+        exitFullscreen()
+    }
+
+    override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
+        if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN || keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
+            handler.removeCallbacks(this)
+            handler.postDelayed(this, 500)
+        }
+        return super.onKeyDown(keyCode, event)
+    }
+
+    override fun attachBaseContext(newBase: Context?) {
+        val code = PreferenceUtil.languageCode
+        if (code != "auto") {
+            super.attachBaseContext(LanguageContextWrapper.wrap(newBase, Locale(code)))
+        } else super.attachBaseContext(newBase)
+    }
+}

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

@@ -0,0 +1,342 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities.bugreport
+
+import android.app.Activity
+import android.app.Dialog
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import android.text.TextUtils
+import android.view.MenuItem
+import android.view.inputmethod.EditorInfo
+import android.widget.Toast
+import androidx.annotation.StringDef
+import androidx.annotation.StringRes
+import androidx.appcompat.app.AlertDialog
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.appthemehelper.util.ATHUtil
+import code.name.monkey.appthemehelper.util.MaterialUtil
+import code.name.monkey.appthemehelper.util.TintHelper
+import code.name.monkey.appthemehelper.util.ToolbarContentTintHelper
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.base.AbsThemeActivity
+import code.name.monkey.retromusic.activities.bugreport.model.DeviceInfo
+import code.name.monkey.retromusic.activities.bugreport.model.Report
+import code.name.monkey.retromusic.activities.bugreport.model.github.ExtraInfo
+import code.name.monkey.retromusic.activities.bugreport.model.github.GithubLogin
+import code.name.monkey.retromusic.activities.bugreport.model.github.GithubTarget
+import code.name.monkey.retromusic.misc.DialogAsyncTask
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.floatingactionbutton.FloatingActionButton
+import com.google.android.material.textfield.TextInputLayout
+import java.io.IOException
+import kotlinx.android.synthetic.main.activity_bug_report.*
+import kotlinx.android.synthetic.main.bug_report_card_device_info.*
+import kotlinx.android.synthetic.main.bug_report_card_report.*
+import org.eclipse.egit.github.core.Issue
+import org.eclipse.egit.github.core.client.GitHubClient
+import org.eclipse.egit.github.core.client.RequestException
+import org.eclipse.egit.github.core.service.IssueService
+
+private const val RESULT_SUCCESS = "RESULT_OK"
+private const val RESULT_BAD_CREDENTIALS = "RESULT_BAD_CREDENTIALS"
+private const val RESULT_INVALID_TOKEN = "RESULT_INVALID_TOKEN"
+private const val RESULT_ISSUES_NOT_ENABLED = "RESULT_ISSUES_NOT_ENABLED"
+private const val RESULT_UNKNOWN = "RESULT_UNKNOWN"
+
+@StringDef(
+    RESULT_SUCCESS,
+    RESULT_BAD_CREDENTIALS,
+    RESULT_INVALID_TOKEN,
+    RESULT_ISSUES_NOT_ENABLED,
+    RESULT_UNKNOWN
+)
+@Retention(AnnotationRetention.SOURCE)
+private annotation class Result
+
+open class BugReportActivity : AbsThemeActivity() {
+
+    private var deviceInfo: DeviceInfo? = null
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_bug_report)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setTaskDescriptionColorAuto()
+
+        initViews()
+
+        if (TextUtils.isEmpty(title)) setTitle(R.string.report_an_issue)
+
+        deviceInfo = DeviceInfo(this)
+        airTextDeviceInfo.text = deviceInfo.toString()
+    }
+
+    private fun initViews() {
+        val accentColor = ThemeStore.accentColor(this)
+        val primaryColor = ATHUtil.resolveColor(this, R.attr.colorSurface)
+        toolbar.setBackgroundColor(primaryColor)
+        setSupportActionBar(toolbar)
+        ToolbarContentTintHelper.colorBackButton(toolbar)
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+        TintHelper.setTintAuto(optionUseAccount, accentColor, false)
+        optionUseAccount?.setOnClickListener {
+            inputTitle.isEnabled = true
+            inputDescription.isEnabled = true
+            inputUsername.isEnabled = true
+            inputPassword.isEnabled = true
+
+            optionAnonymous.isChecked = false
+            sendFab.hide(object : FloatingActionButton.OnVisibilityChangedListener() {
+                override fun onHidden(fab: FloatingActionButton?) {
+                    super.onHidden(fab)
+                    sendFab.setImageResource(R.drawable.ic_send)
+                    sendFab.show()
+                }
+            })
+        }
+        TintHelper.setTintAuto(optionAnonymous, accentColor, false)
+        optionAnonymous.setOnClickListener {
+            inputTitle.isEnabled = false
+            inputDescription.isEnabled = false
+            inputUsername.isEnabled = false
+            inputPassword.isEnabled = false
+
+            optionUseAccount.isChecked = false
+            sendFab.hide(object : FloatingActionButton.OnVisibilityChangedListener() {
+                override fun onHidden(fab: FloatingActionButton?) {
+                    super.onHidden(fab)
+                    sendFab.setImageResource(R.drawable.ic_open_in_browser)
+                    sendFab.show()
+                }
+            })
+        }
+
+        inputPassword.setOnEditorActionListener { _, actionId, _ ->
+            if (actionId == EditorInfo.IME_ACTION_SEND) {
+                reportIssue()
+                return@setOnEditorActionListener true
+            }
+            false
+        }
+
+        airTextDeviceInfo.setOnClickListener { copyDeviceInfoToClipBoard() }
+
+        TintHelper.setTintAuto(sendFab, accentColor, true)
+        sendFab.setOnClickListener { reportIssue() }
+
+        MaterialUtil.setTint(inputLayoutTitle, false)
+        MaterialUtil.setTint(inputLayoutDescription, false)
+        MaterialUtil.setTint(inputLayoutUsername, false)
+        MaterialUtil.setTint(inputLayoutPassword, false)
+    }
+
+    private fun reportIssue() {
+        if (optionUseAccount.isChecked) {
+            if (!validateInput()) return
+            val username = inputUsername.text.toString()
+            val password = inputPassword.text.toString()
+            sendBugReport(GithubLogin(username, password))
+        } else {
+            copyDeviceInfoToClipBoard()
+
+            val i = Intent(Intent.ACTION_VIEW)
+            i.data = Uri.parse(ISSUE_TRACKER_LINK)
+            i.flags = Intent.FLAG_ACTIVITY_NEW_TASK
+            startActivity(i)
+        }
+    }
+
+    private fun copyDeviceInfoToClipBoard() {
+        val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+        val clip = ClipData.newPlainText(getString(R.string.device_info), deviceInfo?.toMarkdown())
+        clipboard.setPrimaryClip(clip)
+        Toast.makeText(
+            this@BugReportActivity,
+            R.string.copied_device_info_to_clipboard,
+            Toast.LENGTH_LONG
+        ).show()
+    }
+
+    private fun validateInput(): Boolean {
+        var hasErrors = false
+
+        if (optionUseAccount.isChecked) {
+            if (TextUtils.isEmpty(inputUsername.text)) {
+                setError(inputLayoutUsername, R.string.bug_report_no_username)
+                hasErrors = true
+            } else {
+                removeError(inputLayoutUsername)
+            }
+
+            if (TextUtils.isEmpty(inputPassword.text)) {
+                setError(inputLayoutPassword, R.string.bug_report_no_password)
+                hasErrors = true
+            } else {
+                removeError(inputLayoutPassword)
+            }
+        }
+
+        if (TextUtils.isEmpty(inputTitle.text)) {
+            setError(inputLayoutTitle, R.string.bug_report_no_title)
+            hasErrors = true
+        } else {
+            removeError(inputLayoutTitle)
+        }
+
+        if (TextUtils.isEmpty(inputDescription.text)) {
+            setError(inputLayoutDescription, R.string.bug_report_no_description)
+            hasErrors = true
+        } else {
+            removeError(inputLayoutDescription)
+        }
+
+        return !hasErrors
+    }
+
+    private fun setError(editTextLayout: TextInputLayout, @StringRes errorRes: Int) {
+        editTextLayout.error = getString(errorRes)
+    }
+
+    private fun removeError(editTextLayout: TextInputLayout) {
+        editTextLayout.error = null
+    }
+
+    private fun sendBugReport(login: GithubLogin) {
+        if (!validateInput()) return
+
+        val bugTitle = inputTitle.text.toString()
+        val bugDescription = inputDescription.text.toString()
+
+        val extraInfo = ExtraInfo()
+        onSaveExtraInfo()
+
+        val report = Report(bugTitle, bugDescription, deviceInfo, extraInfo)
+        val target = GithubTarget("h4h13", "RetroMusicPlayer")
+
+        ReportIssueAsyncTask.report(this, report, target, login)
+    }
+
+    private fun onSaveExtraInfo() {}
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        if (item.itemId == android.R.id.home) {
+            onBackPressed()
+        }
+        return super.onOptionsItemSelected(item)
+    }
+
+    private class ReportIssueAsyncTask private constructor(
+        activity: Activity,
+        private val report: Report,
+        private val target: GithubTarget,
+        private val login: GithubLogin
+    ) : DialogAsyncTask<Void, Void, String>(activity) {
+
+        override fun createDialog(context: Context): Dialog {
+            return AlertDialog.Builder(context).show()
+        }
+
+        @Result
+        override fun doInBackground(vararg params: Void): String {
+            val client: GitHubClient = if (login.shouldUseApiToken()) {
+                GitHubClient().setOAuth2Token(login.apiToken)
+            } else {
+                GitHubClient().setCredentials(login.username, login.password)
+            }
+
+            val issue = Issue().setTitle(report.title).setBody(report.description)
+            try {
+                IssueService(client).createIssue(target.username, target.repository, issue)
+                return RESULT_SUCCESS
+            } catch (e: RequestException) {
+                return when (e.status) {
+                    STATUS_BAD_CREDENTIALS -> {
+                        if (login.shouldUseApiToken()) RESULT_INVALID_TOKEN else RESULT_BAD_CREDENTIALS
+                    }
+                    STATUS_ISSUES_NOT_ENABLED -> RESULT_ISSUES_NOT_ENABLED
+                    else -> {
+                        e.printStackTrace()
+                        RESULT_UNKNOWN
+                    }
+                }
+            } catch (e: IOException) {
+                e.printStackTrace()
+                return RESULT_UNKNOWN
+            }
+        }
+
+        override fun onPostExecute(@Result result: String) {
+            super.onPostExecute(result)
+
+            val context = context ?: return
+
+            when (result) {
+                RESULT_SUCCESS -> tryToFinishActivity()
+                RESULT_BAD_CREDENTIALS -> MaterialAlertDialogBuilder(context)
+                    .setTitle(R.string.bug_report_failed)
+                    .setMessage(R.string.bug_report_failed_wrong_credentials)
+                    .setPositiveButton(android.R.string.ok, null)
+                    .show()
+                RESULT_INVALID_TOKEN -> MaterialAlertDialogBuilder(context)
+                    .setTitle(R.string.bug_report_failed)
+                    .setMessage(R.string.bug_report_failed_invalid_token)
+                    .setPositiveButton(android.R.string.ok, null).show()
+                RESULT_ISSUES_NOT_ENABLED -> MaterialAlertDialogBuilder(context)
+                    .setTitle(R.string.bug_report_failed)
+                    .setMessage(R.string.bug_report_failed_issues_not_available)
+                    .setPositiveButton(android.R.string.ok, null)
+
+                else -> MaterialAlertDialogBuilder(context)
+                    .setTitle(R.string.bug_report_failed)
+                    .setMessage(R.string.bug_report_failed_unknown)
+                    .setPositiveButton(android.R.string.ok) { _, _ -> tryToFinishActivity() }
+                    .setNegativeButton(android.R.string.cancel) { _, _ -> tryToFinishActivity() }
+            }
+        }
+
+        private fun tryToFinishActivity() {
+            val context = context
+            if (context is Activity && !context.isFinishing) {
+                context.finish()
+            }
+        }
+
+        companion object {
+
+            fun report(
+                activity: Activity,
+                report: Report,
+                target: GithubTarget,
+                login: GithubLogin
+            ) {
+                ReportIssueAsyncTask(activity, report, target, login).execute()
+            }
+        }
+    }
+
+    companion object {
+
+        private const val STATUS_BAD_CREDENTIALS = 401
+        private const val STATUS_ISSUES_NOT_ENABLED = 410
+        private const val ISSUE_TRACKER_LINK = "https://github.com/h4h13/RetroMusicPlayer"
+    }
+}

app/src/main/java/code/name/monkey/retromusic/activities/bugreport/model/DeviceInfo.java

@@ -0,0 +1,205 @@
+package code.name.monkey.retromusic.activities.bugreport.model;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import androidx.annotation.IntRange;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Locale;
+
+import code.name.monkey.retromusic.util.PreferenceUtil;
+
+public class DeviceInfo {
+
+  @SuppressLint("NewApi")
+  @SuppressWarnings("deprecation")
+  private final String[] abis =
+      Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP
+          ? Build.SUPPORTED_ABIS
+          : new String[] {Build.CPU_ABI, Build.CPU_ABI2};
+
+  @SuppressLint("NewApi")
+  private final String[] abis32Bits =
+      Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP ? Build.SUPPORTED_32_BIT_ABIS : null;
+
+  @SuppressLint("NewApi")
+  private final String[] abis64Bits =
+      Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP ? Build.SUPPORTED_64_BIT_ABIS : null;
+
+  private final String baseTheme;
+
+  private final String brand = Build.BRAND;
+
+  private final String buildID = Build.DISPLAY;
+
+  private final String buildVersion = Build.VERSION.INCREMENTAL;
+
+  private final String device = Build.DEVICE;
+
+  private final String hardware = Build.HARDWARE;
+
+  private final boolean isAdaptive;
+
+  private final String manufacturer = Build.MANUFACTURER;
+
+  private final String model = Build.MODEL;
+
+  private final String nowPlayingTheme;
+
+  private final String product = Build.PRODUCT;
+
+  private final String releaseVersion = Build.VERSION.RELEASE;
+
+  @IntRange(from = 0)
+  private final int sdkVersion = Build.VERSION.SDK_INT;
+
+  private final int versionCode;
+
+  private final String versionName;
+  private final String selectedLang;
+
+  public DeviceInfo(@NotNull Context context) {
+    PackageInfo packageInfo;
+    try {
+      packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
+    } catch (PackageManager.NameNotFoundException e) {
+      packageInfo = null;
+    }
+    if (packageInfo != null) {
+      versionCode = packageInfo.versionCode;
+      versionName = packageInfo.versionName;
+    } else {
+      versionCode = -1;
+      versionName = null;
+    }
+    baseTheme = PreferenceUtil.INSTANCE.getBaseTheme();
+    nowPlayingTheme =
+        context.getString(PreferenceUtil.INSTANCE.getNowPlayingScreen().getTitleRes());
+    isAdaptive = PreferenceUtil.INSTANCE.isAdaptiveColor();
+    selectedLang = PreferenceUtil.INSTANCE.getLanguageCode();
+  }
+
+  public String toMarkdown() {
+    return "Device info:\n"
+        + "---\n"
+        + "<table>\n"
+        + "<tr><td><b>App version</b></td><td>"
+        + versionName
+        + "</td></tr>\n"
+        + "<tr><td>App version code</td><td>"
+        + versionCode
+        + "</td></tr>\n"
+        + "<tr><td>Android build version</td><td>"
+        + buildVersion
+        + "</td></tr>\n"
+        + "<tr><td>Android release version</td><td>"
+        + releaseVersion
+        + "</td></tr>\n"
+        + "<tr><td>Android SDK version</td><td>"
+        + sdkVersion
+        + "</td></tr>\n"
+        + "<tr><td>Android build ID</td><td>"
+        + buildID
+        + "</td></tr>\n"
+        + "<tr><td>Device brand</td><td>"
+        + brand
+        + "</td></tr>\n"
+        + "<tr><td>Device manufacturer</td><td>"
+        + manufacturer
+        + "</td></tr>\n"
+        + "<tr><td>Device name</td><td>"
+        + device
+        + "</td></tr>\n"
+        + "<tr><td>Device model</td><td>"
+        + model
+        + "</td></tr>\n"
+        + "<tr><td>Device product name</td><td>"
+        + product
+        + "</td></tr>\n"
+        + "<tr><td>Device hardware name</td><td>"
+        + hardware
+        + "</td></tr>\n"
+        + "<tr><td>ABIs</td><td>"
+        + Arrays.toString(abis)
+        + "</td></tr>\n"
+        + "<tr><td>ABIs (32bit)</td><td>"
+        + Arrays.toString(abis32Bits)
+        + "</td></tr>\n"
+        + "<tr><td>ABIs (64bit)</td><td>"
+        + Arrays.toString(abis64Bits)
+        + "</td></tr>\n"
+        + "<tr><td>Language</td><td>"
+        + selectedLang
+        + "</td></tr>\n"
+        + "</table>\n";
+  }
+
+  @NotNull
+  @Override
+  public String toString() {
+    return "App version: "
+        + versionName
+        + "\n"
+        + "App version code: "
+        + versionCode
+        + "\n"
+        + "Android build version: "
+        + buildVersion
+        + "\n"
+        + "Android release version: "
+        + releaseVersion
+        + "\n"
+        + "Android SDK version: "
+        + sdkVersion
+        + "\n"
+        + "Android build ID: "
+        + buildID
+        + "\n"
+        + "Device brand: "
+        + brand
+        + "\n"
+        + "Device manufacturer: "
+        + manufacturer
+        + "\n"
+        + "Device name: "
+        + device
+        + "\n"
+        + "Device model: "
+        + model
+        + "\n"
+        + "Device product name: "
+        + product
+        + "\n"
+        + "Device hardware name: "
+        + hardware
+        + "\n"
+        + "ABIs: "
+        + Arrays.toString(abis)
+        + "\n"
+        + "ABIs (32bit): "
+        + Arrays.toString(abis32Bits)
+        + "\n"
+        + "ABIs (64bit): "
+        + Arrays.toString(abis64Bits)
+        + "\n"
+        + "Base theme: "
+        + baseTheme
+        + "\n"
+        + "Now playing theme: "
+        + nowPlayingTheme
+        + "\n"
+        + "Adaptive: "
+        + isAdaptive
+        + "\n"
+        + "System language: "
+        + Locale.getDefault().toLanguageTag()
+        + "\n"
+        + "In-App Language: "
+        + selectedLang;
+  }
+}

app/src/main/java/code/name/monkey/retromusic/activities/bugreport/model/Report.java

@@ -0,0 +1,34 @@
+package code.name.monkey.retromusic.activities.bugreport.model;
+
+import code.name.monkey.retromusic.activities.bugreport.model.github.ExtraInfo;
+
+public class Report {
+
+  private final String description;
+
+  private final DeviceInfo deviceInfo;
+
+  private final ExtraInfo extraInfo;
+
+  private final String title;
+
+  public Report(String title, String description, DeviceInfo deviceInfo, ExtraInfo extraInfo) {
+    this.title = title;
+    this.description = description;
+    this.deviceInfo = deviceInfo;
+    this.extraInfo = extraInfo;
+  }
+
+  public String getDescription() {
+    return description
+        + "\n\n"
+        + "-\n\n"
+        + deviceInfo.toMarkdown()
+        + "\n\n"
+        + extraInfo.toMarkdown();
+  }
+
+  public String getTitle() {
+    return title;
+  }
+}

app/src/main/java/code/name/monkey/retromusic/activities/bugreport/model/github/ExtraInfo.java

@@ -0,0 +1,61 @@
+package code.name.monkey.retromusic.activities.bugreport.model.github;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class ExtraInfo {
+
+  private final Map<String, String> extraInfo = new LinkedHashMap<>();
+
+  public void put(String key, String value) {
+    extraInfo.put(key, value);
+  }
+
+  public void put(String key, boolean value) {
+    extraInfo.put(key, Boolean.toString(value));
+  }
+
+  public void put(String key, double value) {
+    extraInfo.put(key, Double.toString(value));
+  }
+
+  public void put(String key, float value) {
+    extraInfo.put(key, Float.toString(value));
+  }
+
+  public void put(String key, long value) {
+    extraInfo.put(key, Long.toString(value));
+  }
+
+  public void put(String key, int value) {
+    extraInfo.put(key, Integer.toString(value));
+  }
+
+  public void put(String key, Object value) {
+    extraInfo.put(key, String.valueOf(value));
+  }
+
+  public void remove(String key) {
+    extraInfo.remove(key);
+  }
+
+  public String toMarkdown() {
+    if (extraInfo.isEmpty()) {
+      return "";
+    }
+
+    StringBuilder output = new StringBuilder();
+    output.append("Extra info:\n" + "---\n" + "<table>\n");
+    for (String key : extraInfo.keySet()) {
+      output
+          .append("<tr><td>")
+          .append(key)
+          .append("</td><td>")
+          .append(extraInfo.get(key))
+          .append("</td></tr>\n");
+    }
+    output.append("</table>\n");
+
+    return output.toString();
+  }
+}

app/src/main/java/code/name/monkey/retromusic/activities/bugreport/model/github/GithubLogin.java

@@ -0,0 +1,40 @@
+package code.name.monkey.retromusic.activities.bugreport.model.github;
+
+import android.text.TextUtils;
+
+public class GithubLogin {
+
+  private final String apiToken;
+
+  private final String password;
+
+  private final String username;
+
+  public GithubLogin(String username, String password) {
+    this.username = username;
+    this.password = password;
+    this.apiToken = null;
+  }
+
+  public GithubLogin(String apiToken) {
+    this.username = null;
+    this.password = null;
+    this.apiToken = apiToken;
+  }
+
+  public String getApiToken() {
+    return apiToken;
+  }
+
+  public String getPassword() {
+    return password;
+  }
+
+  public String getUsername() {
+    return username;
+  }
+
+  public boolean shouldUseApiToken() {
+    return TextUtils.isEmpty(username) || TextUtils.isEmpty(password);
+  }
+}

app/src/main/java/code/name/monkey/retromusic/activities/bugreport/model/github/GithubTarget.java

@@ -0,0 +1,21 @@
+package code.name.monkey.retromusic.activities.bugreport.model.github;
+
+public class GithubTarget {
+
+  private final String repository;
+
+  private final String username;
+
+  public GithubTarget(String username, String repository) {
+    this.username = username;
+    this.repository = repository;
+  }
+
+  public String getRepository() {
+    return repository;
+  }
+
+  public String getUsername() {
+    return username;
+  }
+}

app/src/main/java/code/name/monkey/retromusic/activities/saf/SAFGuideActivity.java

@@ -0,0 +1,73 @@
+/*
+ * 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.activities.saf;
+
+import android.os.Build;
+import android.os.Bundle;
+import androidx.annotation.Nullable;
+import code.name.monkey.retromusic.R;
+import com.heinrichreimersoftware.materialintro.app.IntroActivity;
+import com.heinrichreimersoftware.materialintro.slide.SimpleSlide;
+
+/** Created by hemanths on 2019-07-31. */
+public class SAFGuideActivity extends IntroActivity {
+
+  public static final int REQUEST_CODE_SAF_GUIDE = 98;
+
+  @Override
+  protected void onCreate(@Nullable Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    setButtonCtaVisible(false);
+    setButtonNextVisible(false);
+    setButtonBackVisible(false);
+
+    setButtonCtaTintMode(BUTTON_CTA_TINT_MODE_TEXT);
+
+    String title =
+        String.format(getString(R.string.saf_guide_slide1_title), getString(R.string.app_name));
+
+    addSlide(
+        new SimpleSlide.Builder()
+            .title(title)
+            .description(
+                Build.VERSION.SDK_INT <= Build.VERSION_CODES.N_MR1
+                    ? R.string.saf_guide_slide1_description_before_o
+                    : R.string.saf_guide_slide1_description)
+            .image(R.drawable.saf_guide_1)
+            .background(R.color.md_deep_purple_300)
+            .backgroundDark(R.color.md_deep_purple_400)
+            .layout(R.layout.fragment_simple_slide_large_image)
+            .build());
+    addSlide(
+        new SimpleSlide.Builder()
+            .title(R.string.saf_guide_slide2_title)
+            .description(R.string.saf_guide_slide2_description)
+            .image(R.drawable.saf_guide_2)
+            .background(R.color.md_deep_purple_500)
+            .backgroundDark(R.color.md_deep_purple_600)
+            .layout(R.layout.fragment_simple_slide_large_image)
+            .build());
+    addSlide(
+        new SimpleSlide.Builder()
+            .title(R.string.saf_guide_slide3_title)
+            .description(R.string.saf_guide_slide3_description)
+            .image(R.drawable.saf_guide_3)
+            .background(R.color.md_deep_purple_700)
+            .backgroundDark(R.color.md_deep_purple_800)
+            .layout(R.layout.fragment_simple_slide_large_image)
+            .build());
+  }
+}

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2021 Bartlomiej Uliasz.
+ *
+ * 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.activities.saf
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Bundle
+import code.name.monkey.retromusic.activities.saf.SAFGuideActivity.REQUEST_CODE_SAF_GUIDE
+import code.name.monkey.retromusic.util.SAFUtil
+
+/** Created by buliasz on 2021-02-07.  */
+class SAFRequestActivity : Activity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val intent = Intent(this, SAFGuideActivity::class.java)
+        startActivityForResult(intent, REQUEST_CODE_SAF_GUIDE)
+    }
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) {
+        super.onActivityResult(requestCode, resultCode, intent)
+        when (requestCode) {
+            REQUEST_CODE_SAF_GUIDE -> {
+                SAFUtil.openTreePicker(this)
+            }
+            SAFUtil.REQUEST_SAF_PICK_TREE -> {
+                if (resultCode == RESULT_OK) {
+                    SAFUtil.saveTreeUri(this, intent)
+                }
+                finish()
+            }
+        }
+    }
+}

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

@@ -0,0 +1,399 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities.tageditor
+
+import android.app.Activity
+import android.app.SearchManager
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.net.Uri
+import android.os.Bundle
+import android.util.Log
+import android.view.MenuItem
+import android.view.View
+import android.view.animation.OvershootInterpolator
+import androidx.appcompat.app.AlertDialog
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.appthemehelper.util.ATHUtil
+import code.name.monkey.appthemehelper.util.TintHelper
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.R.drawable
+import code.name.monkey.retromusic.activities.base.AbsBaseActivity
+import code.name.monkey.retromusic.activities.saf.SAFGuideActivity
+import code.name.monkey.retromusic.extensions.accentColor
+import code.name.monkey.retromusic.model.ArtworkInfo
+import code.name.monkey.retromusic.model.LoadingInfo
+import code.name.monkey.retromusic.repository.Repository
+import code.name.monkey.retromusic.util.RetroUtil
+import code.name.monkey.retromusic.util.SAFUtil
+import com.google.android.material.button.MaterialButton
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import kotlinx.android.synthetic.main.activity_album_tag_editor.*
+import org.jaudiotagger.audio.AudioFile
+import org.jaudiotagger.audio.AudioFileIO
+import org.jaudiotagger.tag.FieldKey
+import org.koin.android.ext.android.inject
+import java.io.File
+import java.util.*
+
+abstract class AbsTagEditorActivity : AbsBaseActivity() {
+    val repository by inject<Repository>()
+
+    lateinit var saveFab: MaterialButton
+    protected var id: Long = 0
+        private set
+    private var paletteColorPrimary: Int = 0
+    private var isInNoImageMode: Boolean = false
+    private var songPaths: List<String>? = null
+    private var savedSongPaths: List<String>? = null
+    private val currentSongPath: String? = null
+    private var savedTags: Map<FieldKey, String>? = null
+    private var savedArtworkInfo: ArtworkInfo? = null
+    protected abstract val contentViewLayout: Int
+    protected abstract fun loadImageFromFile(selectedFile: Uri?)
+
+    protected val show: AlertDialog
+        get() =
+            MaterialAlertDialogBuilder(this)
+                .setTitle(R.string.update_image)
+                .setItems(items.toTypedArray()) { _, position ->
+                    when (position) {
+                        0 -> startImagePicker()
+                        1 -> searchImageOnWeb()
+                        2 -> deleteImage()
+                    }
+                }
+                .show()
+
+    internal val albumArtist: String?
+        get() {
+            return try {
+                getAudioFile(songPaths!![0]).tagOrCreateAndSetDefault.getFirst(FieldKey.ALBUM_ARTIST)
+            } catch (ignored: Exception) {
+                null
+            }
+        }
+
+    protected val songTitle: String?
+        get() {
+            return try {
+                getAudioFile(songPaths!![0]).tagOrCreateAndSetDefault.getFirst(FieldKey.TITLE)
+            } catch (ignored: Exception) {
+                null
+            }
+        }
+    protected val composer: String?
+        get() {
+            return try {
+                getAudioFile(songPaths!![0]).tagOrCreateAndSetDefault.getFirst(FieldKey.COMPOSER)
+            } catch (ignored: Exception) {
+                null
+            }
+        }
+
+    protected val albumTitle: String?
+        get() {
+            return try {
+                getAudioFile(songPaths!![0]).tagOrCreateAndSetDefault.getFirst(FieldKey.ALBUM)
+            } catch (ignored: Exception) {
+                null
+            }
+        }
+
+    protected val artistName: String?
+        get() {
+            return try {
+                getAudioFile(songPaths!![0]).tagOrCreateAndSetDefault.getFirst(FieldKey.ARTIST)
+            } catch (ignored: Exception) {
+                null
+            }
+        }
+
+    protected val albumArtistName: String?
+        get() {
+            return try {
+                getAudioFile(songPaths!![0]).tagOrCreateAndSetDefault.getFirst(FieldKey.ALBUM_ARTIST)
+            } catch (ignored: Exception) {
+                null
+            }
+        }
+
+    protected val genreName: String?
+        get() {
+            return try {
+                getAudioFile(songPaths!![0]).tagOrCreateAndSetDefault.getFirst(FieldKey.GENRE)
+            } catch (ignored: Exception) {
+                null
+            }
+        }
+
+    protected val songYear: String?
+        get() {
+            return try {
+                getAudioFile(songPaths!![0]).tagOrCreateAndSetDefault.getFirst(FieldKey.YEAR)
+            } catch (ignored: Exception) {
+                null
+            }
+        }
+
+    protected val trackNumber: String?
+        get() {
+            return try {
+                getAudioFile(songPaths!![0]).tagOrCreateAndSetDefault.getFirst(FieldKey.TRACK)
+            } catch (ignored: Exception) {
+                null
+            }
+        }
+
+    protected val lyrics: String?
+        get() {
+            return try {
+                getAudioFile(songPaths!![0]).tagOrCreateAndSetDefault.getFirst(FieldKey.LYRICS)
+            } catch (ignored: Exception) {
+                null
+            }
+        }
+
+    protected val albumArt: Bitmap?
+        get() {
+            try {
+                val artworkTag = getAudioFile(songPaths!![0]).tagOrCreateAndSetDefault.firstArtwork
+                if (artworkTag != null) {
+                    val artworkBinaryData = artworkTag.binaryData
+                    return BitmapFactory.decodeByteArray(
+                        artworkBinaryData,
+                        0,
+                        artworkBinaryData.size
+                    )
+                }
+                return null
+            } catch (ignored: Exception) {
+                return null
+            }
+        }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(contentViewLayout)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setTaskDescriptionColorAuto()
+
+        saveFab = findViewById(R.id.saveTags)
+        getIntentExtras()
+
+        songPaths = getSongPaths()
+        println(songPaths?.size)
+        if (songPaths!!.isEmpty()) {
+            finish()
+        }
+        setUpViews()
+    }
+
+    private fun setUpViews() {
+        setUpFab()
+        setUpImageView()
+    }
+
+    private lateinit var items: List<String>
+
+    private fun setUpImageView() {
+        loadCurrentImage()
+        items = listOf(
+            getString(R.string.pick_from_local_storage),
+            getString(R.string.web_search),
+            getString(R.string.remove_cover)
+        )
+        editorImage?.setOnClickListener { show }
+    }
+
+    private fun startImagePicker() {
+        val intent = Intent(Intent.ACTION_GET_CONTENT)
+        intent.type = "image/*"
+        startActivityForResult(
+            Intent.createChooser(
+                intent,
+                getString(R.string.pick_from_local_storage)
+            ), REQUEST_CODE_SELECT_IMAGE
+        )
+    }
+
+    protected abstract fun loadCurrentImage()
+
+    protected abstract fun searchImageOnWeb()
+
+    protected abstract fun deleteImage()
+
+    private fun setUpFab() {
+        saveFab.accentColor()
+        saveFab.apply {
+            scaleX = 0f
+            scaleY = 0f
+            isEnabled = false
+            setOnClickListener { save() }
+            TintHelper.setTintAuto(this, ThemeStore.accentColor(this@AbsTagEditorActivity), true)
+        }
+    }
+
+    protected abstract fun save()
+
+    private fun getIntentExtras() {
+        val intentExtras = intent.extras
+        if (intentExtras != null) {
+            id = intentExtras.getLong(EXTRA_ID)
+        }
+    }
+
+    protected abstract fun getSongPaths(): List<String>
+
+    protected fun searchWebFor(vararg keys: String) {
+        val stringBuilder = StringBuilder()
+        for (key in keys) {
+            stringBuilder.append(key)
+            stringBuilder.append(" ")
+        }
+        val intent = Intent(Intent.ACTION_WEB_SEARCH)
+        intent.putExtra(SearchManager.QUERY, stringBuilder.toString())
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+
+        startActivity(intent)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        when (item.itemId) {
+            android.R.id.home -> {
+                super.onBackPressed()
+                return true
+            }
+        }
+        return super.onOptionsItemSelected(item)
+    }
+
+    protected fun setNoImageMode() {
+        isInNoImageMode = true
+        imageContainer?.visibility = View.GONE
+        editorImage?.visibility = View.GONE
+        editorImage?.isEnabled = false
+
+        setColors(
+            intent.getIntExtra(
+                EXTRA_PALETTE,
+                ATHUtil.resolveColor(this, R.attr.colorPrimary)
+            )
+        )
+    }
+
+    protected fun dataChanged() {
+        showFab()
+    }
+
+    private fun showFab() {
+        saveFab.animate().setDuration(500).setInterpolator(OvershootInterpolator()).scaleX(1f)
+            .scaleY(1f).start()
+        saveFab.isEnabled = true
+    }
+
+    private fun hideFab() {
+        saveFab.animate().setDuration(500).setInterpolator(OvershootInterpolator()).scaleX(0.0f)
+            .scaleY(0.0f).start()
+        saveFab.isEnabled = false
+    }
+
+    protected fun setImageBitmap(bitmap: Bitmap?, bgColor: Int) {
+        if (bitmap == null) {
+            editorImage.setImageResource(drawable.default_audio_art)
+        } else {
+            editorImage.setImageBitmap(bitmap)
+        }
+        setColors(bgColor)
+    }
+
+    protected open fun setColors(color: Int) {
+        paletteColorPrimary = color
+    }
+
+    protected fun writeValuesToFiles(
+        fieldKeyValueMap: Map<FieldKey, String>,
+        artworkInfo: ArtworkInfo?
+    ) {
+        RetroUtil.hideSoftKeyboard(this)
+
+        hideFab()
+        println(fieldKeyValueMap)
+        WriteTagsAsyncTask(this).execute(
+            LoadingInfo(
+                songPaths,
+                fieldKeyValueMap,
+                artworkInfo
+            )
+        )
+    }
+
+    private fun writeTags(paths: List<String>?) {
+        WriteTagsAsyncTask(this).execute(
+            LoadingInfo(
+                paths,
+                savedTags,
+                savedArtworkInfo
+            )
+        )
+    }
+
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) {
+        super.onActivityResult(requestCode, resultCode, intent)
+        when (requestCode) {
+            REQUEST_CODE_SELECT_IMAGE -> if (resultCode == Activity.RESULT_OK) {
+                intent?.data?.let {
+                    loadImageFromFile(it)
+                }
+            }
+            SAFGuideActivity.REQUEST_CODE_SAF_GUIDE -> {
+                SAFUtil.openTreePicker(this)
+            }
+            SAFUtil.REQUEST_SAF_PICK_TREE -> {
+                if (resultCode == Activity.RESULT_OK) {
+                    SAFUtil.saveTreeUri(this, intent)
+                    writeTags(savedSongPaths)
+                }
+            }
+            SAFUtil.REQUEST_SAF_PICK_FILE -> {
+                if (resultCode == Activity.RESULT_OK) {
+                    writeTags(Collections.singletonList(currentSongPath + SAFUtil.SEPARATOR + intent!!.dataString))
+                }
+            }
+        }
+    }
+
+
+    private fun getAudioFile(path: String): AudioFile {
+        return try {
+            AudioFileIO.read(File(path))
+        } catch (e: Exception) {
+            Log.e(TAG, "Could not read audio file $path", e)
+            AudioFile()
+        }
+    }
+
+
+    companion object {
+
+        const val EXTRA_ID = "extra_id"
+        const val EXTRA_PALETTE = "extra_palette"
+        private val TAG = AbsTagEditorActivity::class.java.simpleName
+        private const val REQUEST_CODE_SELECT_IMAGE = 1000
+    }
+}

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

@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities.tageditor
+
+import android.app.Activity
+import android.content.res.ColorStateList
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Color
+import android.graphics.drawable.Drawable
+import android.net.Uri
+import android.os.Bundle
+import android.text.Editable
+import android.text.TextWatcher
+import android.transition.Slide
+import android.widget.Toast
+import code.name.monkey.appthemehelper.util.ATHUtil
+import code.name.monkey.appthemehelper.util.MaterialUtil
+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.model.ArtworkInfo
+import code.name.monkey.retromusic.model.Song
+import code.name.monkey.retromusic.util.ImageUtil
+import code.name.monkey.retromusic.util.RetroColorUtil.generatePalette
+import code.name.monkey.retromusic.util.RetroColorUtil.getColor
+import com.bumptech.glide.Glide
+import com.bumptech.glide.load.engine.DiskCacheStrategy
+import com.bumptech.glide.request.animation.GlideAnimation
+import com.bumptech.glide.request.target.SimpleTarget
+import java.util.*
+import kotlinx.android.synthetic.main.activity_album_tag_editor.*
+import org.jaudiotagger.tag.FieldKey
+
+class AlbumTagEditorActivity : AbsTagEditorActivity(), TextWatcher {
+
+    override val contentViewLayout: Int
+        get() = R.layout.activity_album_tag_editor
+
+    private fun windowEnterTransition() {
+        val slide = Slide()
+        slide.excludeTarget(R.id.appBarLayout, true)
+        slide.excludeTarget(R.id.status_bar, true)
+        slide.excludeTarget(android.R.id.statusBarBackground, true)
+        slide.excludeTarget(android.R.id.navigationBarBackground, true)
+
+        window.enterTransition = slide
+    }
+
+    override fun loadImageFromFile(selectedFile: Uri?) {
+
+        Glide.with(this@AlbumTagEditorActivity).load(selectedFile).asBitmap()
+            .transcode(BitmapPaletteTranscoder(this), BitmapPaletteWrapper::class.java)
+            .diskCacheStrategy(DiskCacheStrategy.NONE).skipMemoryCache(true)
+            .into(object : SimpleTarget<BitmapPaletteWrapper>() {
+                override fun onResourceReady(
+                    resource: BitmapPaletteWrapper?,
+                    glideAnimation: GlideAnimation<in BitmapPaletteWrapper>?
+                ) {
+                    getColor(resource?.palette, Color.TRANSPARENT)
+                    albumArtBitmap = resource?.bitmap?.let { ImageUtil.resizeBitmap(it, 2048) }
+                    setImageBitmap(
+                        albumArtBitmap,
+                        getColor(
+                            resource?.palette,
+                            ATHUtil.resolveColor(
+                                this@AlbumTagEditorActivity,
+                                R.attr.defaultFooterColor
+                            )
+                        )
+                    )
+                    deleteAlbumArt = false
+                    dataChanged()
+                    setResult(Activity.RESULT_OK)
+                }
+
+                override fun onLoadFailed(e: Exception?, errorDrawable: Drawable?) {
+                    super.onLoadFailed(e, errorDrawable)
+                    Toast.makeText(this@AlbumTagEditorActivity, e.toString(), Toast.LENGTH_LONG)
+                        .show()
+                }
+            })
+    }
+
+    private var albumArtBitmap: Bitmap? = null
+    private var deleteAlbumArt: Boolean = false
+
+    private fun setupToolbar() {
+        toolbar.setBackgroundColor(ATHUtil.resolveColor(this, R.attr.colorSurface))
+        setSupportActionBar(toolbar)
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        window.sharedElementsUseOverlay = true
+        imageContainer?.transitionName = getString(R.string.transition_album_art)
+        windowEnterTransition()
+        setUpViews()
+        setupToolbar()
+    }
+
+    private fun setUpViews() {
+        fillViewsWithFileTags()
+
+        MaterialUtil.setTint(yearContainer, false)
+        MaterialUtil.setTint(genreContainer, false)
+        MaterialUtil.setTint(albumTitleContainer, false)
+        MaterialUtil.setTint(albumArtistContainer, false)
+
+        albumText.appHandleColor().addTextChangedListener(this)
+        albumArtistText.appHandleColor().addTextChangedListener(this)
+        genreTitle.appHandleColor().addTextChangedListener(this)
+        yearTitle.appHandleColor().addTextChangedListener(this)
+    }
+
+    private fun fillViewsWithFileTags() {
+        albumText.setText(albumTitle)
+        albumArtistText.setText(albumArtistName)
+        genreTitle.setText(genreName)
+        yearTitle.setText(songYear)
+    }
+
+    override fun loadCurrentImage() {
+        val bitmap = albumArt
+        setImageBitmap(
+            bitmap,
+            getColor(
+                generatePalette(bitmap),
+                ATHUtil.resolveColor(this, R.attr.defaultFooterColor)
+            )
+        )
+        deleteAlbumArt = false
+    }
+
+    private fun toastLoadingFailed() {
+        Toast.makeText(
+            this@AlbumTagEditorActivity,
+            R.string.could_not_download_album_cover,
+            Toast.LENGTH_SHORT
+        ).show()
+    }
+
+    override fun searchImageOnWeb() {
+        searchWebFor(albumText.text.toString(), albumArtistText.text.toString())
+    }
+
+    override fun deleteImage() {
+        setImageBitmap(
+            BitmapFactory.decodeResource(resources, R.drawable.default_audio_art),
+            ATHUtil.resolveColor(this, R.attr.defaultFooterColor)
+        )
+        deleteAlbumArt = true
+        dataChanged()
+    }
+
+    override fun save() {
+        val fieldKeyValueMap = EnumMap<FieldKey, String>(FieldKey::class.java)
+        fieldKeyValueMap[FieldKey.ALBUM] = albumText.text.toString()
+        // android seems not to recognize album_artist field so we additionally write the normal artist field
+        fieldKeyValueMap[FieldKey.ARTIST] = albumArtistText.text.toString()
+        fieldKeyValueMap[FieldKey.ALBUM_ARTIST] = albumArtistText.text.toString()
+        fieldKeyValueMap[FieldKey.GENRE] = genreTitle.text.toString()
+        fieldKeyValueMap[FieldKey.YEAR] = yearTitle.text.toString()
+
+        writeValuesToFiles(
+            fieldKeyValueMap,
+            when {
+                deleteAlbumArt -> ArtworkInfo(id, null)
+                albumArtBitmap == null -> null
+                else -> ArtworkInfo(id, albumArtBitmap!!)
+            }
+        )
+    }
+
+    override fun getSongPaths(): List<String> {
+        return repository.albumById(id).songs
+            .map(Song::data)
+    }
+
+    override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {
+    }
+
+    override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {
+    }
+
+    override fun afterTextChanged(s: Editable) {
+        dataChanged()
+    }
+
+    override fun setColors(color: Int) {
+        super.setColors(color)
+        saveFab.backgroundTintList = ColorStateList.valueOf(color)
+    }
+
+    companion object {
+
+        val TAG: String = AlbumTagEditorActivity::class.java.simpleName
+    }
+}

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

@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.activities.tageditor
+
+import android.net.Uri
+import android.os.Bundle
+import android.text.Editable
+import android.text.TextWatcher
+import code.name.monkey.appthemehelper.util.ATHUtil
+import code.name.monkey.appthemehelper.util.MaterialUtil
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.extensions.appHandleColor
+import code.name.monkey.retromusic.repository.SongRepository
+import kotlinx.android.synthetic.main.activity_song_tag_editor.*
+import org.jaudiotagger.tag.FieldKey
+import org.koin.android.ext.android.inject
+import java.util.*
+
+class SongTagEditorActivity : AbsTagEditorActivity(), TextWatcher {
+
+    override val contentViewLayout: Int
+        get() = R.layout.activity_song_tag_editor
+
+    private val songRepository by inject<SongRepository>()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        setNoImageMode()
+        setUpViews()
+        toolbar.setBackgroundColor(ATHUtil.resolveColor(this, R.attr.colorSurface))
+        setSupportActionBar(toolbar)
+    }
+
+    private fun setUpViews() {
+        fillViewsWithFileTags()
+        MaterialUtil.setTint(songTextContainer, false)
+        MaterialUtil.setTint(composerContainer, false)
+        MaterialUtil.setTint(albumTextContainer, false)
+        MaterialUtil.setTint(artistContainer, false)
+        MaterialUtil.setTint(albumArtistContainer, false)
+        MaterialUtil.setTint(yearContainer, false)
+        MaterialUtil.setTint(genreContainer, false)
+        MaterialUtil.setTint(trackNumberContainer, false)
+        MaterialUtil.setTint(lyricsContainer, false)
+
+        songText.appHandleColor().addTextChangedListener(this)
+        albumText.appHandleColor().addTextChangedListener(this)
+        albumArtistText.appHandleColor().addTextChangedListener(this)
+        artistText.appHandleColor().addTextChangedListener(this)
+        genreText.appHandleColor().addTextChangedListener(this)
+        yearText.appHandleColor().addTextChangedListener(this)
+        trackNumberText.appHandleColor().addTextChangedListener(this)
+        lyricsText.appHandleColor().addTextChangedListener(this)
+        songComposerText.appHandleColor().addTextChangedListener(this)
+    }
+
+    private fun fillViewsWithFileTags() {
+        songText.setText(songTitle)
+        albumArtistText.setText(albumArtist)
+        albumText.setText(albumTitle)
+        artistText.setText(artistName)
+        genreText.setText(genreName)
+        yearText.setText(songYear)
+        trackNumberText.setText(trackNumber)
+        lyricsText.setText(lyrics)
+        songComposerText.setText(composer)
+    }
+
+    override fun loadCurrentImage() {
+    }
+
+    override fun searchImageOnWeb() {
+    }
+
+    override fun deleteImage() {
+    }
+
+    override fun save() {
+        val fieldKeyValueMap = EnumMap<FieldKey, String>(FieldKey::class.java)
+        fieldKeyValueMap[FieldKey.TITLE] = songText.text.toString()
+        fieldKeyValueMap[FieldKey.ALBUM] = albumText.text.toString()
+        fieldKeyValueMap[FieldKey.ARTIST] = artistText.text.toString()
+        fieldKeyValueMap[FieldKey.GENRE] = genreText.text.toString()
+        fieldKeyValueMap[FieldKey.YEAR] = yearText.text.toString()
+        fieldKeyValueMap[FieldKey.TRACK] = trackNumberText.text.toString()
+        fieldKeyValueMap[FieldKey.LYRICS] = lyricsText.text.toString()
+        fieldKeyValueMap[FieldKey.ALBUM_ARTIST] = albumArtistText.text.toString()
+        fieldKeyValueMap[FieldKey.COMPOSER] = songComposerText.text.toString()
+        writeValuesToFiles(fieldKeyValueMap, null)
+    }
+
+    override fun getSongPaths(): List<String> = listOf(songRepository.song(id).data)
+
+    override fun loadImageFromFile(selectedFile: Uri?) {
+    }
+
+    override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {
+    }
+
+    override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {
+    }
+
+    override fun afterTextChanged(s: Editable) {
+        dataChanged()
+    }
+
+    companion object {
+        val TAG: String = SongTagEditorActivity::class.java.simpleName
+    }
+}

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

@@ -0,0 +1,152 @@
+package code.name.monkey.retromusic.activities.tageditor;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.media.MediaScannerConnection;
+import android.util.Log;
+import android.widget.Toast;
+
+import androidx.annotation.NonNull;
+
+import com.afollestad.materialdialogs.MaterialDialog;
+
+import org.jaudiotagger.audio.AudioFile;
+import org.jaudiotagger.audio.AudioFileIO;
+import org.jaudiotagger.audio.exceptions.CannotReadException;
+import org.jaudiotagger.audio.exceptions.CannotWriteException;
+import org.jaudiotagger.audio.exceptions.InvalidAudioFrameException;
+import org.jaudiotagger.audio.exceptions.ReadOnlyFileException;
+import org.jaudiotagger.tag.FieldKey;
+import org.jaudiotagger.tag.Tag;
+import org.jaudiotagger.tag.TagException;
+import org.jaudiotagger.tag.images.Artwork;
+import org.jaudiotagger.tag.images.ArtworkFactory;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import code.name.monkey.retromusic.R;
+import code.name.monkey.retromusic.misc.DialogAsyncTask;
+import code.name.monkey.retromusic.misc.UpdateToastMediaScannerCompletionListener;
+import code.name.monkey.retromusic.model.LoadingInfo;
+import code.name.monkey.retromusic.util.MusicUtil;
+
+public class WriteTagsAsyncTask extends DialogAsyncTask<LoadingInfo, Integer, List<String>> {
+
+    public WriteTagsAsyncTask(Context context) {
+        super(context);
+    }
+
+    @Override
+    protected List<String> doInBackground(LoadingInfo... params) {
+        try {
+            LoadingInfo info = params[0];
+
+            Artwork artwork = null;
+            File albumArtFile = null;
+            if (info.getArtworkInfo() != null && info.getArtworkInfo().getArtwork() != null) {
+                try {
+                    albumArtFile = MusicUtil.INSTANCE.createAlbumArtFile().getCanonicalFile();
+                    info.getArtworkInfo().getArtwork().compress(Bitmap.CompressFormat.PNG, 0, new FileOutputStream(albumArtFile));
+                    artwork = ArtworkFactory.createArtworkFromFile(albumArtFile);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            int counter = 0;
+            boolean wroteArtwork = false;
+            boolean deletedArtwork = false;
+            for (String filePath : info.getFilePaths()) {
+                publishProgress(++counter, info.getFilePaths().size());
+                try {
+                    AudioFile audioFile = AudioFileIO.read(new File(filePath));
+                    Tag tag = audioFile.getTagOrCreateAndSetDefault();
+
+                    if (info.getFieldKeyValueMap() != null) {
+                        for (Map.Entry<FieldKey, String> entry : info.getFieldKeyValueMap().entrySet()) {
+                            try {
+                                tag.setField(entry.getKey(), entry.getValue());
+                            } catch (Exception e) {
+                                e.printStackTrace();
+                            }
+                        }
+                    }
+
+                    if (info.getArtworkInfo() != null) {
+                        if (info.getArtworkInfo().getArtwork() == null) {
+                            tag.deleteArtworkField();
+                            deletedArtwork = true;
+                        } else if (artwork != null) {
+                            tag.deleteArtworkField();
+                            tag.setField(artwork);
+                            wroteArtwork = true;
+                        }
+                    }
+
+                    audioFile.commit();
+                } catch (@NonNull CannotReadException | IOException | CannotWriteException | TagException | ReadOnlyFileException | InvalidAudioFrameException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            Context context = getContext();
+            if (context != null) {
+                if (wroteArtwork) {
+                    MusicUtil.INSTANCE.
+                            insertAlbumArt(context, info.getArtworkInfo().getAlbumId(), albumArtFile.getPath());
+                } else if (deletedArtwork) {
+                    MusicUtil.INSTANCE.deleteAlbumArt(context, info.getArtworkInfo().getAlbumId());
+                }
+            }
+
+            return info.getFilePaths();
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    @Override
+    protected void onPostExecute(List<String> toBeScanned) {
+        super.onPostExecute(toBeScanned);
+        scan(toBeScanned);
+    }
+
+    @Override
+    protected void onCancelled(List<String> toBeScanned) {
+        super.onCancelled(toBeScanned);
+        scan(toBeScanned);
+    }
+
+    private void scan(List<String> toBeScanned) {
+        Context context = getContext();
+        if (toBeScanned == null || toBeScanned.isEmpty()) {
+            Log.i("scan", "scan: Empty");
+            Toast.makeText(context, "Scan file from folder", Toast.LENGTH_SHORT).show();
+            return;
+        }
+        MediaScannerConnection.scanFile(context, toBeScanned.toArray(new String[0]), null, context instanceof Activity ? new UpdateToastMediaScannerCompletionListener((Activity) context, toBeScanned) : null);
+    }
+
+    @Override
+    protected Dialog createDialog(@NonNull Context context) {
+        return new MaterialDialog.Builder(context)
+                .title(R.string.saving_changes)
+                .cancelable(false)
+                .progress(false, 0)
+                .build();
+    }
+
+    @Override
+    protected void onProgressUpdate(@NonNull Dialog dialog, Integer... values) {
+        super.onProgressUpdate(dialog, values);
+        ((MaterialDialog) dialog).setMaxProgress(values[1]);
+        ((MaterialDialog) dialog).setProgress(values[0]);
+    }
+}

app/src/main/java/code/name/monkey/retromusic/adapter/CategoryInfoAdapter.java

@@ -0,0 +1,140 @@
+/*
+ * 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.adapter;
+
+import android.annotation.SuppressLint;
+import android.content.res.ColorStateList;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+import android.widget.Toast;
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.ItemTouchHelper;
+import androidx.recyclerview.widget.RecyclerView;
+import code.name.monkey.appthemehelper.ThemeStore;
+import code.name.monkey.retromusic.R;
+import code.name.monkey.retromusic.model.CategoryInfo;
+import code.name.monkey.retromusic.util.SwipeAndDragHelper;
+import com.google.android.material.checkbox.MaterialCheckBox;
+import java.util.List;
+
+public class CategoryInfoAdapter extends RecyclerView.Adapter<CategoryInfoAdapter.ViewHolder>
+    implements SwipeAndDragHelper.ActionCompletionContract {
+
+  private List<CategoryInfo> categoryInfos;
+  private ItemTouchHelper touchHelper;
+
+  public CategoryInfoAdapter() {
+    SwipeAndDragHelper swipeAndDragHelper = new SwipeAndDragHelper(this);
+    touchHelper = new ItemTouchHelper(swipeAndDragHelper);
+  }
+
+  public void attachToRecyclerView(RecyclerView recyclerView) {
+    touchHelper.attachToRecyclerView(recyclerView);
+  }
+
+  @NonNull
+  public List<CategoryInfo> getCategoryInfos() {
+    return categoryInfos;
+  }
+
+  public void setCategoryInfos(@NonNull List<CategoryInfo> categoryInfos) {
+    this.categoryInfos = categoryInfos;
+    notifyDataSetChanged();
+  }
+
+  @Override
+  public int getItemCount() {
+    return categoryInfos.size();
+  }
+
+  @SuppressLint("ClickableViewAccessibility")
+  @Override
+  public void onBindViewHolder(@NonNull CategoryInfoAdapter.ViewHolder holder, int position) {
+    CategoryInfo categoryInfo = categoryInfos.get(position);
+
+    holder.checkBox.setChecked(categoryInfo.isVisible());
+    holder.title.setText(
+        holder.title.getResources().getString(categoryInfo.getCategory().getStringRes()));
+
+    holder.itemView.setOnClickListener(
+        v -> {
+          if (!(categoryInfo.isVisible() && isLastCheckedCategory(categoryInfo))) {
+            categoryInfo.setVisible(!categoryInfo.isVisible());
+            holder.checkBox.setChecked(categoryInfo.isVisible());
+          } else {
+            Toast.makeText(
+                    holder.itemView.getContext(),
+                    R.string.you_have_to_select_at_least_one_category,
+                    Toast.LENGTH_SHORT)
+                .show();
+          }
+        });
+
+    holder.dragView.setOnTouchListener(
+        (view, event) -> {
+          if (event.getActionMasked() == MotionEvent.ACTION_DOWN) {
+            touchHelper.startDrag(holder);
+          }
+          return false;
+        });
+  }
+
+  @Override
+  @NonNull
+  public CategoryInfoAdapter.ViewHolder onCreateViewHolder(
+      @NonNull ViewGroup parent, int viewType) {
+    View view =
+        LayoutInflater.from(parent.getContext())
+            .inflate(R.layout.preference_dialog_library_categories_listitem, parent, false);
+    return new ViewHolder(view);
+  }
+
+  @Override
+  public void onViewMoved(int oldPosition, int newPosition) {
+    CategoryInfo categoryInfo = categoryInfos.get(oldPosition);
+    categoryInfos.remove(oldPosition);
+    categoryInfos.add(newPosition, categoryInfo);
+    notifyItemMoved(oldPosition, newPosition);
+  }
+
+  private boolean isLastCheckedCategory(CategoryInfo categoryInfo) {
+    if (categoryInfo.isVisible()) {
+      for (CategoryInfo c : categoryInfos) {
+        if (c != categoryInfo && c.isVisible()) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  static class ViewHolder extends RecyclerView.ViewHolder {
+    private MaterialCheckBox checkBox;
+    private View dragView;
+    private TextView title;
+
+    ViewHolder(View view) {
+      super(view);
+      checkBox = view.findViewById(R.id.checkbox);
+      checkBox.setButtonTintList(
+          ColorStateList.valueOf(ThemeStore.Companion.accentColor(checkBox.getContext())));
+      title = view.findViewById(R.id.title);
+      dragView = view.findViewById(R.id.drag_view);
+    }
+  }
+}

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

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter
+
+import android.app.Activity
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.TextView
+import androidx.recyclerview.widget.RecyclerView
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.model.Contributor
+import code.name.monkey.retromusic.util.RetroUtil.openUrl
+import code.name.monkey.retromusic.views.RetroShapeableImageView
+import com.bumptech.glide.Glide
+
+class ContributorAdapter(
+    private var contributors: List<Contributor>
+) : RecyclerView.Adapter<ContributorAdapter.ViewHolder>() {
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        return if (viewType == HEADER) {
+            ViewHolder(
+                LayoutInflater.from(parent.context).inflate(
+                    R.layout.item_contributor_header,
+                    parent,
+                    false
+                )
+            )
+        } else ViewHolder(
+            LayoutInflater.from(parent.context).inflate(
+                R.layout.item_contributor,
+                parent,
+                false
+            )
+        )
+    }
+
+    companion object {
+        const val HEADER: Int = 0
+        const val ITEM: Int = 1
+    }
+
+    override fun getItemViewType(position: Int): Int {
+        return if (position == 0) {
+            HEADER
+        } else {
+            ITEM
+        }
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val contributor = contributors[position]
+        holder.bindData(contributor)
+        holder.itemView.setOnClickListener {
+            openUrl(it?.context as Activity, contributors[position].link)
+        }
+    }
+
+    override fun getItemCount(): Int {
+        return contributors.size
+    }
+
+    fun swapData(it: List<Contributor>) {
+        contributors = it
+        notifyDataSetChanged()
+    }
+
+    inner class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
+        val title: TextView = itemView.findViewById(R.id.title)
+        val text: TextView = itemView.findViewById(R.id.text)
+        val image: RetroShapeableImageView = itemView.findViewById(R.id.icon)
+
+        internal fun bindData(contributor: Contributor) {
+            title.text = contributor.name
+            text.text = contributor.summary
+            Glide.with(image.context)
+                .load(contributor.image)
+                .error(R.drawable.ic_account)
+                .placeholder(R.drawable.ic_account)
+                .dontAnimate()
+                .into(image)
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter
+
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.view.ViewCompat
+import androidx.fragment.app.FragmentActivity
+import androidx.recyclerview.widget.RecyclerView
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.adapter.base.MediaEntryViewHolder
+import code.name.monkey.retromusic.interfaces.IGenreClickListener
+import code.name.monkey.retromusic.model.Genre
+import java.util.*
+
+/**
+ * @author Hemanth S (h4h13).
+ */
+
+class GenreAdapter(
+    private val activity: FragmentActivity,
+    var dataSet: List<Genre>,
+    private val mItemLayoutRes: Int,
+    private val listener: IGenreClickListener
+) : RecyclerView.Adapter<GenreAdapter.ViewHolder>() {
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        return ViewHolder(LayoutInflater.from(activity).inflate(mItemLayoutRes, parent, false))
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val genre = dataSet[position]
+        holder.title?.text = genre.name
+        holder.text?.text = String.format(
+            Locale.getDefault(),
+            "%d %s",
+            genre.songCount,
+            if (genre.songCount > 1) activity.getString(R.string.songs) else activity.getString(R.string.song)
+        )
+    }
+
+    override fun getItemCount(): Int {
+        return dataSet.size
+    }
+
+    fun swapDataSet(list: List<Genre>) {
+        dataSet = list
+        notifyDataSetChanged()
+    }
+
+    inner class ViewHolder(itemView: View) : MediaEntryViewHolder(itemView) {
+        override fun onClick(v: View?) {
+            ViewCompat.setTransitionName(itemView, "genre")
+            listener.onClickGenre(dataSet[layoutPosition], itemView)
+        }
+    }
+}

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

@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter
+
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ImageView
+import android.widget.TextView
+import androidx.appcompat.app.AppCompatActivity
+import androidx.appcompat.widget.AppCompatTextView
+import androidx.core.os.bundleOf
+import androidx.navigation.findNavController
+import androidx.navigation.fragment.FragmentNavigatorExtras
+import androidx.recyclerview.widget.GridLayoutManager
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.appthemehelper.util.ColorUtil
+import code.name.monkey.retromusic.*
+import code.name.monkey.retromusic.adapter.album.AlbumAdapter
+import code.name.monkey.retromusic.adapter.artist.ArtistAdapter
+import code.name.monkey.retromusic.adapter.song.SongAdapter
+import code.name.monkey.retromusic.extensions.hide
+import code.name.monkey.retromusic.glide.SongGlideRequest
+import code.name.monkey.retromusic.helper.MusicPlayerRemote
+import code.name.monkey.retromusic.interfaces.IAlbumClickListener
+import code.name.monkey.retromusic.interfaces.IArtistClickListener
+import code.name.monkey.retromusic.interfaces.IGenreClickListener
+import code.name.monkey.retromusic.model.*
+import code.name.monkey.retromusic.util.PreferenceUtil
+import com.bumptech.glide.Glide
+import com.google.android.material.card.MaterialCardView
+
+class HomeAdapter(
+    private val activity: AppCompatActivity
+) : RecyclerView.Adapter<RecyclerView.ViewHolder>(), IArtistClickListener, IAlbumClickListener,
+    IGenreClickListener {
+
+    private var list = listOf<Home>()
+
+    override fun getItemViewType(position: Int): Int {
+        return list[position].homeSection
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
+        val layout =
+            LayoutInflater.from(activity).inflate(R.layout.section_recycler_view, parent, false)
+        return when (viewType) {
+            RECENT_ARTISTS, TOP_ARTISTS -> ArtistViewHolder(layout)
+            GENRES -> GenreViewHolder(layout)
+            FAVOURITES -> PlaylistViewHolder(layout)
+            TOP_ALBUMS, RECENT_ALBUMS -> AlbumViewHolder(layout)
+            else -> {
+                SuggestionsViewHolder(
+                    LayoutInflater.from(activity).inflate(
+                        R.layout.item_suggestions,
+                        parent,
+                        false
+                    )
+                )
+            }
+        }
+    }
+
+    override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
+        val home = list[position]
+        when (getItemViewType(position)) {
+            RECENT_ALBUMS -> {
+                val viewHolder = holder as AlbumViewHolder
+                viewHolder.bindView(home)
+                viewHolder.clickableArea.setOnClickListener {
+                    activity.findNavController(R.id.fragment_container).navigate(
+                        R.id.detailListFragment,
+                        bundleOf("type" to RECENT_ALBUMS)
+                    )
+                }
+            }
+            TOP_ALBUMS -> {
+                val viewHolder = holder as AlbumViewHolder
+                viewHolder.bindView(home)
+                viewHolder.clickableArea.setOnClickListener {
+                    activity.findNavController(R.id.fragment_container).navigate(
+                        R.id.detailListFragment,
+                        bundleOf("type" to TOP_ALBUMS)
+                    )
+                }
+            }
+            RECENT_ARTISTS -> {
+                val viewHolder = holder as ArtistViewHolder
+                viewHolder.bindView(home)
+                viewHolder.clickableArea.setOnClickListener {
+                    activity.findNavController(R.id.fragment_container).navigate(
+                        R.id.detailListFragment,
+                        bundleOf("type" to RECENT_ARTISTS)
+                    )
+                }
+            }
+            TOP_ARTISTS -> {
+                val viewHolder = holder as ArtistViewHolder
+                viewHolder.bindView(home)
+                viewHolder.clickableArea.setOnClickListener {
+                    activity.findNavController(R.id.fragment_container).navigate(
+                        R.id.detailListFragment,
+                        bundleOf("type" to TOP_ARTISTS)
+                    )
+                }
+            }
+            SUGGESTIONS -> {
+                val viewHolder = holder as SuggestionsViewHolder
+                viewHolder.bindView(home)
+            }
+            FAVOURITES -> {
+                val viewHolder = holder as PlaylistViewHolder
+                viewHolder.bindView(home)
+                viewHolder.clickableArea.setOnClickListener {
+                    activity.findNavController(R.id.fragment_container).navigate(
+                        R.id.detailListFragment,
+                        bundleOf("type" to FAVOURITES)
+                    )
+                }
+            }
+            GENRES -> {
+                val viewHolder = holder as GenreViewHolder
+                viewHolder.bind(home)
+            }
+            PLAYLISTS -> {
+            }
+        }
+    }
+
+    override fun getItemCount(): Int {
+        return list.size
+    }
+
+    fun swapData(sections: List<Home>) {
+        list = sections
+        notifyDataSetChanged()
+    }
+
+    private inner class AlbumViewHolder(view: View) : AbsHomeViewItem(view) {
+        fun bindView(home: Home) {
+            title.setText(home.titleRes)
+            recyclerView.apply {
+                adapter = albumAdapter(home.arrayList as List<Album>)
+                layoutManager = gridLayoutManager()
+            }
+        }
+    }
+
+    private inner class ArtistViewHolder(view: View) : AbsHomeViewItem(view) {
+        fun bindView(home: Home) {
+            title.setText(home.titleRes)
+            recyclerView.apply {
+                layoutManager = linearLayoutManager()
+                adapter = artistsAdapter(home.arrayList as List<Artist>)
+            }
+        }
+    }
+
+    private inner class SuggestionsViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
+        private val images = listOf(
+            R.id.image1,
+            R.id.image2,
+            R.id.image3,
+            R.id.image4,
+            R.id.image5,
+            R.id.image6,
+            R.id.image7,
+            R.id.image8
+        )
+
+        fun bindView(home: Home) {
+            val color = ThemeStore.accentColor(activity)
+            itemView.findViewById<TextView>(R.id.message).setTextColor(color)
+            itemView.findViewById<MaterialCardView>(R.id.card6).apply {
+                setCardBackgroundColor(ColorUtil.withAlpha(color, 0.12f))
+            }
+            images.forEachIndexed { index, id ->
+                itemView.findViewById<View>(id).setOnClickListener {
+                    MusicPlayerRemote.playNext(home.arrayList[index] as Song)
+                }
+                SongGlideRequest.Builder.from(Glide.with(activity), home.arrayList[index] as Song)
+                    .asBitmap()
+                    .build()
+                    .into(itemView.findViewById(id))
+            }
+        }
+    }
+
+    private inner class PlaylistViewHolder(view: View) : AbsHomeViewItem(view) {
+        fun bindView(home: Home) {
+            title.setText(home.titleRes)
+            recyclerView.apply {
+                val songAdapter = SongAdapter(
+                    activity,
+                    home.arrayList as MutableList<Song>,
+                    R.layout.item_album_card, null
+                )
+                layoutManager = linearLayoutManager()
+                adapter = songAdapter
+            }
+        }
+    }
+
+    private inner class GenreViewHolder(itemView: View) : AbsHomeViewItem(itemView) {
+        fun bind(home: Home) {
+            arrow.hide()
+            title.setText(home.titleRes)
+            val genreAdapter = GenreAdapter(
+                activity,
+                home.arrayList as List<Genre>,
+                R.layout.item_grid_genre,
+                this@HomeAdapter
+            )
+            recyclerView.apply {
+                layoutManager = GridLayoutManager(activity, 3, GridLayoutManager.HORIZONTAL, false)
+                adapter = genreAdapter
+            }
+        }
+    }
+
+    open class AbsHomeViewItem(itemView: View) : RecyclerView.ViewHolder(itemView) {
+        val recyclerView: RecyclerView = itemView.findViewById(R.id.recyclerView)
+        val title: AppCompatTextView = itemView.findViewById(R.id.title)
+        val arrow: ImageView = itemView.findViewById(R.id.arrow)
+        val clickableArea: ViewGroup = itemView.findViewById(R.id.clickable_area)
+    }
+
+    private fun artistsAdapter(artists: List<Artist>) =
+        ArtistAdapter(activity, artists, PreferenceUtil.homeArtistGridStyle, null, this)
+
+    private fun albumAdapter(albums: List<Album>) =
+        AlbumAdapter(activity, albums, PreferenceUtil.homeAlbumGridStyle, null, this)
+
+    private fun gridLayoutManager() =
+        GridLayoutManager(activity, 1, GridLayoutManager.HORIZONTAL, false)
+
+    private fun linearLayoutManager() =
+        LinearLayoutManager(activity, LinearLayoutManager.HORIZONTAL, false)
+
+    override fun onArtist(artistId: Long, view: View) {
+        activity.findNavController(R.id.fragment_container).navigate(
+            R.id.artistDetailsFragment,
+            bundleOf(EXTRA_ARTIST_ID to artistId),
+            null,
+            FragmentNavigatorExtras(
+                view to "artist"
+            )
+        )
+    }
+
+    override fun onAlbumClick(albumId: Long, view: View) {
+        activity.findNavController(R.id.fragment_container).navigate(
+            R.id.albumDetailsFragment,
+            bundleOf(EXTRA_ALBUM_ID to albumId),
+            null,
+            FragmentNavigatorExtras(
+                view to "album"
+            )
+        )
+    }
+
+    override fun onClickGenre(genre: Genre, view: View) {
+        activity.findNavController(R.id.fragment_container).navigate(
+            R.id.genreDetailsFragment,
+            bundleOf(EXTRA_GENRE to genre),
+            null,
+            FragmentNavigatorExtras(
+                view to "genre"
+            )
+        )
+    }
+
+}

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

@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter
+
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.os.bundleOf
+import androidx.core.view.isGone
+import androidx.core.view.isInvisible
+import androidx.core.view.isVisible
+import androidx.fragment.app.FragmentActivity
+import androidx.navigation.findNavController
+import androidx.recyclerview.widget.RecyclerView
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.retromusic.*
+import code.name.monkey.retromusic.adapter.base.MediaEntryViewHolder
+import code.name.monkey.retromusic.db.PlaylistEntity
+import code.name.monkey.retromusic.db.PlaylistWithSongs
+import code.name.monkey.retromusic.glide.AlbumGlideRequest
+import code.name.monkey.retromusic.glide.ArtistGlideRequest
+import code.name.monkey.retromusic.helper.MusicPlayerRemote
+import code.name.monkey.retromusic.helper.menu.SongMenuHelper
+import code.name.monkey.retromusic.model.*
+import code.name.monkey.retromusic.model.smartplaylist.AbsSmartPlaylist
+import code.name.monkey.retromusic.repository.PlaylistSongsLoader
+import code.name.monkey.retromusic.util.MusicUtil
+import com.bumptech.glide.Glide
+import java.util.*
+
+class SearchAdapter(
+    private val activity: FragmentActivity,
+    private var dataSet: List<Any>
+) : RecyclerView.Adapter<SearchAdapter.ViewHolder>() {
+
+    fun swapDataSet(dataSet: List<Any>) {
+        this.dataSet = dataSet
+        notifyDataSetChanged()
+    }
+
+    override fun getItemViewType(position: Int): Int {
+        if (dataSet[position] is Album) return ALBUM
+        if (dataSet[position] is Artist) return ARTIST
+        if (dataSet[position] is Genre) return GENRE
+        if (dataSet[position] is PlaylistEntity) return PLAYLIST
+        return if (dataSet[position] is Song) SONG else HEADER
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        return if (viewType == HEADER) ViewHolder(
+            LayoutInflater.from(activity).inflate(
+                R.layout.sub_header,
+                parent,
+                false
+            ), viewType
+        )
+        else
+            ViewHolder(
+                LayoutInflater.from(activity).inflate(R.layout.item_list, parent, false),
+                viewType
+            )
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        when (getItemViewType(position)) {
+            ALBUM -> {
+                holder.imageTextContainer?.isVisible = true
+                val album = dataSet[position] as Album
+                holder.title?.text = album.title
+                holder.text?.text = album.artistName
+                AlbumGlideRequest.Builder.from(Glide.with(activity), album.safeGetFirstSong())
+                    .checkIgnoreMediaStore().build().into(holder.image)
+            }
+            ARTIST -> {
+                holder.imageTextContainer?.isVisible = true
+                val artist = dataSet[position] as Artist
+                holder.title?.text = artist.name
+                holder.text?.text = MusicUtil.getArtistInfoString(activity, artist)
+                ArtistGlideRequest.Builder.from(Glide.with(activity), artist).build()
+                    .into(holder.image)
+            }
+            SONG -> {
+                val song = dataSet[position] as Song
+                holder.title?.text = song.title
+                holder.text?.text = song.albumName
+            }
+            GENRE -> {
+                val genre = dataSet[position] as Genre
+                holder.title?.text = genre.name
+                holder.text?.text = String.format(
+                    Locale.getDefault(),
+                    "%d %s",
+                    genre.songCount,
+                    if (genre.songCount > 1) activity.getString(R.string.songs) else activity.getString(
+                        R.string.song
+                    )
+                )
+            }
+            PLAYLIST -> {
+                val playlist = dataSet[position] as PlaylistEntity
+                holder.title?.text = playlist.playlistName
+                //holder.text?.text = MusicUtil.playlistInfoString(activity, playlist.songs)
+            }
+            else -> {
+                holder.title?.text = dataSet[position].toString()
+                holder.title?.setTextColor(ThemeStore.accentColor(activity))
+            }
+        }
+    }
+
+    private fun getSongs(playlist: Playlist): List<Song> {
+        val songs = mutableListOf<Song>()
+        if (playlist is AbsSmartPlaylist) {
+            songs.addAll(playlist.getSongs())
+        } else {
+            songs.addAll(PlaylistSongsLoader.getPlaylistSongList(activity, playlist.id))
+        }
+        return songs
+    }
+
+    override fun getItemCount(): Int {
+        return dataSet.size
+    }
+
+    inner class ViewHolder(itemView: View, itemViewType: Int) : MediaEntryViewHolder(itemView) {
+        init {
+            itemView.setOnLongClickListener(null)
+            imageTextContainer?.isInvisible = true
+            if (itemViewType == SONG) {
+                imageTextContainer?.isGone = true
+                menu?.visibility = View.VISIBLE
+                menu?.setOnClickListener(object : SongMenuHelper.OnClickSongMenu(activity) {
+                    override val song: Song
+                        get() = dataSet[layoutPosition] as Song
+                })
+            } else {
+                menu?.visibility = View.GONE
+            }
+
+            when (itemViewType) {
+                ALBUM -> setImageTransitionName(activity.getString(R.string.transition_album_art))
+                ARTIST -> setImageTransitionName(activity.getString(R.string.transition_artist_image))
+                else -> {
+                    val container = itemView.findViewById<View>(R.id.imageContainer)
+                    container?.visibility = View.GONE
+                }
+            }
+        }
+
+        override fun onClick(v: View?) {
+            val item = dataSet[layoutPosition]
+            when (itemViewType) {
+                ALBUM -> {
+                    activity.findNavController(R.id.fragment_container).navigate(
+                        R.id.albumDetailsFragment,
+                        bundleOf(EXTRA_ALBUM_ID to (item as Album).id)
+                    )
+                }
+                ARTIST -> {
+                    activity.findNavController(R.id.fragment_container).navigate(
+                        R.id.artistDetailsFragment,
+                        bundleOf(EXTRA_ARTIST_ID to (item as Artist).id)
+                    )
+                }
+                GENRE -> {
+                    activity.findNavController(R.id.fragment_container).navigate(
+                        R.id.genreDetailsFragment,
+                        bundleOf(EXTRA_GENRE to (item as Genre))
+                    )
+                }
+                PLAYLIST -> {
+                    activity.findNavController(R.id.fragment_container).navigate(
+                        R.id.playlistDetailsFragment,
+                        bundleOf(EXTRA_PLAYLIST to (item as PlaylistWithSongs))
+                    )
+                }
+                SONG -> {
+                    val playList = mutableListOf<Song>()
+                    playList.add(item as Song)
+                    MusicPlayerRemote.openQueue(playList, 0, true)
+                }
+            }
+        }
+    }
+
+    companion object {
+        private const val HEADER = 0
+        private const val ALBUM = 1
+        private const val ARTIST = 2
+        private const val SONG = 3
+        private const val GENRE = 4
+        private const val PLAYLIST = 5
+    }
+}

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

@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter
+
+import android.graphics.PorterDuff
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import androidx.appcompat.app.AppCompatActivity
+import code.name.monkey.appthemehelper.util.ATHUtil
+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.audiocover.AudioFileCover
+import code.name.monkey.retromusic.interfaces.ICabHolder
+import code.name.monkey.retromusic.interfaces.ICallbacks
+import code.name.monkey.retromusic.util.MusicUtil
+import code.name.monkey.retromusic.util.RetroUtil
+import com.bumptech.glide.Glide
+import com.bumptech.glide.load.engine.DiskCacheStrategy
+import com.bumptech.glide.signature.MediaStoreSignature
+import java.io.File
+import java.text.DecimalFormat
+import kotlin.math.log10
+import kotlin.math.pow
+import me.zhanghai.android.fastscroll.PopupTextProvider
+
+class SongFileAdapter(
+    private val activity: AppCompatActivity,
+    private var dataSet: List<File>,
+    private val itemLayoutRes: Int,
+    private val iCallbacks: ICallbacks?,
+    iCabHolder: ICabHolder?
+) : AbsMultiSelectAdapter<SongFileAdapter.ViewHolder, File>(
+    activity, iCabHolder, R.menu.menu_media_selection
+), PopupTextProvider {
+
+    init {
+        this.setHasStableIds(true)
+    }
+
+    override fun getItemViewType(position: Int): Int {
+        return if (dataSet[position].isDirectory) FOLDER else FILE
+    }
+
+    override fun getItemId(position: Int): Long {
+        return dataSet[position].hashCode().toLong()
+    }
+
+    fun swapDataSet(songFiles: List<File>) {
+        this.dataSet = songFiles
+        notifyDataSetChanged()
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        return ViewHolder(LayoutInflater.from(activity).inflate(itemLayoutRes, parent, false))
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, index: Int) {
+        val file = dataSet[index]
+        holder.itemView.isActivated = isChecked(file)
+        holder.title?.text = getFileTitle(file)
+        if (holder.text != null) {
+            if (holder.itemViewType == FILE) {
+                holder.text?.text = getFileText(file)
+            } else {
+                holder.text?.visibility = View.GONE
+            }
+        }
+
+        if (holder.image != null) {
+            loadFileImage(file, holder)
+        }
+    }
+
+    private fun getFileTitle(file: File): String {
+        return file.name
+    }
+
+    private fun getFileText(file: File): String? {
+        return if (file.isDirectory) null else readableFileSize(file.length())
+    }
+
+    private fun loadFileImage(file: File, holder: ViewHolder) {
+        val iconColor = ATHUtil.resolveColor(activity, R.attr.colorControlNormal)
+        if (file.isDirectory) {
+            holder.image?.let {
+                it.setColorFilter(iconColor, PorterDuff.Mode.SRC_IN)
+                it.setImageResource(R.drawable.ic_folder)
+            }
+            holder.imageTextContainer?.setCardBackgroundColor(
+                ATHUtil.resolveColor(
+                    activity,
+                    R.attr.colorSurface
+                )
+            )
+        } else {
+            val error = RetroUtil.getTintedVectorDrawable(
+                activity, R.drawable.ic_file_music, iconColor
+            )
+            Glide.with(activity)
+                .load(AudioFileCover(file.path))
+                .diskCacheStrategy(DiskCacheStrategy.NONE)
+                .error(error)
+                .placeholder(error)
+                .animate(android.R.anim.fade_in)
+                .signature(MediaStoreSignature("", file.lastModified(), 0))
+                .into(holder.image)
+        }
+    }
+
+    override fun getItemCount(): Int {
+        return dataSet.size
+    }
+
+    override fun getIdentifier(position: Int): File? {
+        return dataSet[position]
+    }
+
+    override fun getName(`object`: File): String {
+        return getFileTitle(`object`)
+    }
+
+    override fun onMultipleItemAction(menuItem: MenuItem, selection: List<File>) {
+        if (iCallbacks == null) return
+        iCallbacks.onMultipleItemAction(menuItem, selection as ArrayList<File>)
+    }
+
+    override fun getPopupText(position: Int): String {
+        return getSectionName(position)
+    }
+
+    private fun getSectionName(position: Int): String {
+        return MusicUtil.getSectionName(dataSet[position].name)
+    }
+
+    inner class ViewHolder(itemView: View) : MediaEntryViewHolder(itemView) {
+
+        init {
+            if (menu != null && iCallbacks != null) {
+                menu?.setOnClickListener { v ->
+                    val position = layoutPosition
+                    if (isPositionInRange(position)) {
+                        iCallbacks.onFileMenuClicked(dataSet[position], v)
+                    }
+                }
+            }
+            if (imageTextContainer != null) {
+                imageTextContainer?.cardElevation = 0f
+            }
+        }
+
+        override fun onClick(v: View?) {
+            val position = layoutPosition
+            if (isPositionInRange(position)) {
+                if (isInQuickSelectMode) {
+                    toggleChecked(position)
+                } else {
+                    iCallbacks?.onFileSelected(dataSet[position])
+                }
+            }
+        }
+
+        override fun onLongClick(v: View?): Boolean {
+            val position = layoutPosition
+            return isPositionInRange(position) && toggleChecked(position)
+        }
+
+        private fun isPositionInRange(position: Int): Boolean {
+            return position >= 0 && position < dataSet.size
+        }
+    }
+
+    companion object {
+
+        private const val FILE = 0
+        private const val FOLDER = 1
+
+        fun readableFileSize(size: Long): String {
+            if (size <= 0) return "$size B"
+            val units = arrayOf("B", "KB", "MB", "GB", "TB")
+            val digitGroups = (log10(size.toDouble()) / log10(1024.0)).toInt()
+            return DecimalFormat("#,##0.##").format(size / 1024.0.pow(digitGroups.toDouble())) + " " + units[digitGroups]
+        }
+    }
+}

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

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter
+
+import android.app.Activity
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.TextView
+import androidx.recyclerview.widget.RecyclerView
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.extensions.hide
+import code.name.monkey.retromusic.model.Contributor
+import code.name.monkey.retromusic.util.RetroUtil
+import code.name.monkey.retromusic.views.RetroShapeableImageView
+
+class TranslatorsAdapter(
+    private var contributors: List<Contributor>
+) : RecyclerView.Adapter<TranslatorsAdapter.ViewHolder>() {
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        return ViewHolder(
+            LayoutInflater.from(parent.context).inflate(
+                R.layout.item_contributor,
+                parent,
+                false
+            )
+        )
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val contributor = contributors[position]
+        holder.bindData(contributor)
+        holder.itemView.setOnClickListener {
+            RetroUtil.openUrl(it?.context as Activity, contributors[position].link)
+        }
+    }
+
+    override fun getItemCount(): Int {
+        return contributors.size
+    }
+
+    inner class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
+        val title: TextView = itemView.findViewById(R.id.title)
+        val text: TextView = itemView.findViewById(R.id.text)
+        val image: RetroShapeableImageView = itemView.findViewById(R.id.icon)
+
+        internal fun bindData(contributor: Contributor) {
+            title.text = contributor.name
+            text.text = contributor.summary
+            image.hide()
+        }
+    }
+}

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

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter.album
+
+import android.content.res.ColorStateList
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.view.ViewCompat
+import androidx.fragment.app.FragmentActivity
+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.AlbumGlideRequest
+import code.name.monkey.retromusic.glide.RetroMusicColoredTarget
+import code.name.monkey.retromusic.helper.SortOrder
+import code.name.monkey.retromusic.helper.menu.SongsMenuHelper
+import code.name.monkey.retromusic.interfaces.IAlbumClickListener
+import code.name.monkey.retromusic.interfaces.ICabHolder
+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.PreferenceUtil
+import code.name.monkey.retromusic.util.color.MediaNotificationProcessor
+import com.bumptech.glide.Glide
+import me.zhanghai.android.fastscroll.PopupTextProvider
+
+open class AlbumAdapter(
+    val activity: FragmentActivity,
+    var dataSet: List<Album>,
+    var itemLayoutRes: Int,
+    iCabHolder: ICabHolder?,
+    val listener: IAlbumClickListener?
+) : AbsMultiSelectAdapter<AlbumAdapter.ViewHolder, Album>(
+    activity,
+    iCabHolder,
+    R.menu.menu_media_selection
+), PopupTextProvider {
+
+    init {
+        this.setHasStableIds(true)
+    }
+
+    fun swapDataSet(dataSet: List<Album>) {
+        this.dataSet = dataSet
+        notifyDataSetChanged()
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        val view = LayoutInflater.from(activity).inflate(itemLayoutRes, parent, false)
+        return createViewHolder(view, viewType)
+    }
+
+    protected open fun createViewHolder(view: View, viewType: Int): ViewHolder {
+        return ViewHolder(view)
+    }
+
+    private fun getAlbumTitle(album: Album): String? {
+        return album.title
+    }
+
+    protected open fun getAlbumText(album: Album): String? {
+        return album.artistName
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val album = dataSet[position]
+        val isChecked = isChecked(album)
+        holder.itemView.isActivated = isChecked
+        holder.title?.text = getAlbumTitle(album)
+        holder.text?.text = getAlbumText(album)
+        loadAlbumCover(album, holder)
+    }
+
+    protected open fun setColors(color: MediaNotificationProcessor, holder: ViewHolder) {
+        if (holder.paletteColorContainer != null) {
+            holder.title?.setTextColor(color.primaryTextColor)
+            holder.text?.setTextColor(color.secondaryTextColor)
+            holder.paletteColorContainer?.setBackgroundColor(color.backgroundColor)
+        }
+        holder.mask?.backgroundTintList = ColorStateList.valueOf(color.primaryTextColor)
+        holder.imageContainerCard?.setCardBackgroundColor(color.backgroundColor) }
+
+    protected open fun loadAlbumCover(album: Album, holder: ViewHolder) {
+        if (holder.image == null) {
+            return
+        }
+
+        AlbumGlideRequest.Builder.from(Glide.with(activity), album.safeGetFirstSong())
+            .checkIgnoreMediaStore()
+            .generatePalette(activity)
+            .build()
+            .into(object : RetroMusicColoredTarget(holder.image!!) {
+                override fun onColorReady(colors: MediaNotificationProcessor) {
+                    setColors(colors, holder)
+                }
+            })
+    }
+
+    override fun getItemCount(): Int {
+        return dataSet.size
+    }
+
+    override fun getItemId(position: Int): Long {
+        return dataSet[position].id
+    }
+
+    override fun getIdentifier(position: Int): Album? {
+        return dataSet[position]
+    }
+
+    override fun getName(album: Album): String {
+        return album.title!!
+    }
+
+    override fun onMultipleItemAction(
+        menuItem: MenuItem,
+        selection: List<Album>
+    ) {
+        SongsMenuHelper.handleMenuClick(activity, getSongList(selection), menuItem.itemId)
+    }
+
+    private fun getSongList(albums: List<Album>): List<Song> {
+        val songs = ArrayList<Song>()
+        for (album in albums) {
+            songs.addAll(album.songs)
+        }
+        return songs
+    }
+
+    override fun getPopupText(position: Int): String {
+        return getSectionName(position)
+    }
+
+    private fun getSectionName(position: Int): String {
+        var sectionName: String? = null
+        when (PreferenceUtil.albumSortOrder) {
+            SortOrder.AlbumSortOrder.ALBUM_A_Z, SortOrder.AlbumSortOrder.ALBUM_Z_A -> sectionName =
+                dataSet[position].title
+            SortOrder.AlbumSortOrder.ALBUM_ARTIST -> sectionName = dataSet[position].artistName
+            SortOrder.AlbumSortOrder.ALBUM_YEAR -> return MusicUtil.getYearString(
+                dataSet[position].year
+            )
+        }
+        return MusicUtil.getSectionName(sectionName)
+    }
+
+    inner class ViewHolder(itemView: View) : MediaEntryViewHolder(itemView) {
+
+        init {
+            setImageTransitionName("Album")
+            menu?.visibility = View.GONE
+        }
+
+        override fun onClick(v: View?) {
+            super.onClick(v)
+            if (isInQuickSelectMode) {
+                toggleChecked(layoutPosition)
+            } else {
+                image?.let {
+                    ViewCompat.setTransitionName(it, "album")
+                    listener?.onAlbumClick(dataSet[layoutPosition].id, it)
+                }
+
+            }
+        }
+
+        override fun onLongClick(v: View?): Boolean {
+            toggleChecked(layoutPosition)
+            return super.onLongClick(v)
+        }
+    }
+
+    companion object {
+        val TAG: String = AlbumAdapter::class.java.simpleName
+    }
+}

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

@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter.album
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ImageView
+import androidx.core.view.ViewCompat
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentManager
+import androidx.lifecycle.lifecycleScope
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.fragments.AlbumCoverStyle
+import code.name.monkey.retromusic.fragments.NowPlayingScreen.*
+import code.name.monkey.retromusic.glide.RetroMusicColoredTarget
+import code.name.monkey.retromusic.glide.SongGlideRequest
+import code.name.monkey.retromusic.misc.CustomFragmentStatePagerAdapter
+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 code.name.monkey.retromusic.util.color.MediaNotificationProcessor
+import com.bumptech.glide.Glide
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+class AlbumCoverPagerAdapter(
+    fragmentManager: FragmentManager,
+    private val dataSet: List<Song>
+) : CustomFragmentStatePagerAdapter(fragmentManager) {
+
+    private var currentColorReceiver: AlbumCoverFragment.ColorReceiver? = null
+    private var currentColorReceiverPosition = -1
+
+    override fun getItem(position: Int): Fragment {
+        return AlbumCoverFragment.newInstance(dataSet[position])
+    }
+
+    override fun getCount(): Int {
+        return dataSet.size
+    }
+
+    override fun instantiateItem(container: ViewGroup, position: Int): Any {
+        val o = super.instantiateItem(container, position)
+        if (currentColorReceiver != null && currentColorReceiverPosition == position) {
+            receiveColor(currentColorReceiver!!, currentColorReceiverPosition)
+        }
+        return o
+    }
+
+    /**
+     * Only the latest passed [AlbumCoverFragment.ColorReceiver] is guaranteed to receive a
+     * response
+     */
+    fun receiveColor(colorReceiver: AlbumCoverFragment.ColorReceiver, position: Int) {
+
+        if (getFragment(position) is AlbumCoverFragment) {
+            val fragment = getFragment(position) as AlbumCoverFragment
+            currentColorReceiver = null
+            currentColorReceiverPosition = -1
+            fragment.receiveColor(colorReceiver, position)
+        } else {
+            currentColorReceiver = colorReceiver
+            currentColorReceiverPosition = position
+        }
+    }
+
+    class AlbumCoverFragment : Fragment() {
+
+        private lateinit var albumCover: ImageView
+        private var isColorReady: Boolean = false
+        private lateinit var color: MediaNotificationProcessor
+        private lateinit var song: Song
+        private var colorReceiver: ColorReceiver? = null
+        private var request: Int = 0
+
+        override fun onCreate(savedInstanceState: Bundle?) {
+            super.onCreate(savedInstanceState)
+            if (arguments != null) {
+                song = requireArguments().getParcelable(SONG_ARG)!!
+            }
+        }
+
+        override fun onCreateView(
+            inflater: LayoutInflater,
+            container: ViewGroup?,
+            savedInstanceState: Bundle?
+        ): View? {
+            val view = inflater.inflate(getLayoutWithPlayerTheme(), container, false)
+            ViewCompat.setTransitionName(view, "lyrics")
+            albumCover = view.findViewById(R.id.player_image)
+            view.setOnClickListener {
+                showLyricsDialog()
+            }
+            return view
+        }
+
+        private fun showLyricsDialog() {
+            lifecycleScope.launch(Dispatchers.IO) {
+                val data: String? = MusicUtil.getLyrics(song)
+                withContext(Dispatchers.Main) {
+                    MaterialAlertDialogBuilder(
+                        requireContext(),
+                        R.style.ThemeOverlay_MaterialComponents_Dialog_Alert
+                    ).apply {
+                        setTitle(song.title)
+                        setMessage(if (data.isNullOrEmpty()) "No lyrics found" else data)
+                        setNegativeButton(R.string.synced_lyrics) { _, _ ->
+                            NavigationUtil.goToLyrics(requireActivity())
+                        }
+                        show()
+                    }
+                }
+            }
+        }
+
+        private fun getLayoutWithPlayerTheme(): Int {
+            return when (PreferenceUtil.nowPlayingScreen) {
+                Card, Fit, Tiny, Classic, Gradient, Full -> R.layout.fragment_album_full_cover
+                else -> {
+                    if (PreferenceUtil.isCarouselEffect) {
+                        R.layout.fragment_album_carousel_cover
+                    } else {
+                        when (PreferenceUtil.albumCoverStyle) {
+                            AlbumCoverStyle.Normal -> R.layout.fragment_album_cover
+                            AlbumCoverStyle.Flat -> R.layout.fragment_album_flat_cover
+                            AlbumCoverStyle.Circle -> R.layout.fragment_album_circle_cover
+                            AlbumCoverStyle.Card -> R.layout.fragment_album_card_cover
+                            AlbumCoverStyle.Material -> R.layout.fragment_album_material_cover
+                            AlbumCoverStyle.Full -> R.layout.fragment_album_full_cover
+                            AlbumCoverStyle.FullCard -> R.layout.fragment_album_full_card_cover
+                        }
+                    }
+                }
+            }
+        }
+
+        override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+            super.onViewCreated(view, savedInstanceState)
+            loadAlbumCover()
+        }
+
+        override fun onDestroyView() {
+            super.onDestroyView()
+            colorReceiver = null
+        }
+
+        private fun loadAlbumCover() {
+            SongGlideRequest.Builder.from(Glide.with(requireContext()), song)
+                .checkIgnoreMediaStore(requireContext())
+                .generatePalette(requireContext()).build()
+                .into(object : RetroMusicColoredTarget(albumCover) {
+                    override fun onColorReady(colors: MediaNotificationProcessor) {
+                        setColor(colors)
+                    }
+                })
+        }
+
+        private fun setColor(color: MediaNotificationProcessor) {
+            this.color = color
+            isColorReady = true
+            if (colorReceiver != null) {
+                colorReceiver!!.onColorReady(color, request)
+                colorReceiver = null
+            }
+        }
+
+        internal fun receiveColor(colorReceiver: ColorReceiver, request: Int) {
+            if (isColorReady) {
+                colorReceiver.onColorReady(color, request)
+            } else {
+                this.colorReceiver = colorReceiver
+                this.request = request
+            }
+        }
+
+        interface ColorReceiver {
+            fun onColorReady(color: MediaNotificationProcessor, request: Int)
+        }
+
+        companion object {
+
+            private const val SONG_ARG = "song"
+
+            fun newInstance(song: Song): AlbumCoverFragment {
+                val frag = AlbumCoverFragment()
+                val args = Bundle()
+                args.putParcelable(SONG_ARG, song)
+                frag.arguments = args
+                return frag
+            }
+        }
+    }
+
+    companion object {
+        val TAG: String = AlbumCoverPagerAdapter::class.java.simpleName
+    }
+}

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

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter.album
+
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.FragmentActivity
+import code.name.monkey.retromusic.glide.AlbumGlideRequest
+import code.name.monkey.retromusic.glide.RetroMusicColoredTarget
+import code.name.monkey.retromusic.helper.HorizontalAdapterHelper
+import code.name.monkey.retromusic.interfaces.IAlbumClickListener
+import code.name.monkey.retromusic.interfaces.ICabHolder
+import code.name.monkey.retromusic.model.Album
+import code.name.monkey.retromusic.util.MusicUtil
+import code.name.monkey.retromusic.util.color.MediaNotificationProcessor
+import com.bumptech.glide.Glide
+
+class HorizontalAlbumAdapter(
+    activity: FragmentActivity,
+    dataSet: List<Album>,
+    ICabHolder: ICabHolder?,
+    albumClickListener: IAlbumClickListener
+) : AlbumAdapter(
+    activity, dataSet, HorizontalAdapterHelper.LAYOUT_RES, ICabHolder, albumClickListener
+) {
+
+    override fun createViewHolder(view: View, viewType: Int): ViewHolder {
+        val params = view.layoutParams as ViewGroup.MarginLayoutParams
+        HorizontalAdapterHelper.applyMarginToLayoutParams(activity, params, viewType)
+        return ViewHolder(view)
+    }
+
+    override fun setColors(color: MediaNotificationProcessor, holder: ViewHolder) {
+        // holder.title?.setTextColor(ATHUtil.resolveColor(activity, android.R.attr.textColorPrimary))
+        // holder.text?.setTextColor(ATHUtil.resolveColor(activity, android.R.attr.textColorSecondary))
+    }
+
+    override fun loadAlbumCover(album: Album, holder: ViewHolder) {
+        if (holder.image == null) return
+        AlbumGlideRequest.Builder.from(Glide.with(activity), album.safeGetFirstSong())
+            .checkIgnoreMediaStore()
+            .generatePalette(activity)
+            .build()
+            .into(object : RetroMusicColoredTarget(holder.image!!) {
+                override fun onColorReady(colors: MediaNotificationProcessor) {
+                    setColors(colors, holder)
+                }
+            })
+    }
+
+    override fun getAlbumText(album: Album): String? {
+        return MusicUtil.getYearString(album.year)
+    }
+
+    override fun getItemViewType(position: Int): Int {
+        return HorizontalAdapterHelper.getItemViewType(position, itemCount)
+    }
+
+    override fun getItemCount(): Int {
+        return dataSet.size
+    }
+
+    companion object {
+        val TAG: String = AlbumAdapter::class.java.simpleName
+    }
+}

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

@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter.artist
+
+import android.content.res.ColorStateList
+import android.content.res.Resources
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.view.ViewCompat
+import androidx.fragment.app.FragmentActivity
+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.extensions.hide
+import code.name.monkey.retromusic.glide.ArtistGlideRequest
+import code.name.monkey.retromusic.glide.RetroMusicColoredTarget
+import code.name.monkey.retromusic.helper.menu.SongsMenuHelper
+import code.name.monkey.retromusic.interfaces.IArtistClickListener
+import code.name.monkey.retromusic.interfaces.ICabHolder
+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.color.MediaNotificationProcessor
+import com.bumptech.glide.Glide
+import java.util.*
+import me.zhanghai.android.fastscroll.PopupTextProvider
+
+class ArtistAdapter(
+    val activity: FragmentActivity,
+    var dataSet: List<Artist>,
+    var itemLayoutRes: Int,
+    val ICabHolder: ICabHolder?,
+    val IArtistClickListener: IArtistClickListener
+) : AbsMultiSelectAdapter<ArtistAdapter.ViewHolder, Artist>(
+    activity, ICabHolder, R.menu.menu_media_selection
+), PopupTextProvider {
+
+    init {
+        this.setHasStableIds(true)
+    }
+
+    fun swapDataSet(dataSet: List<Artist>) {
+        this.dataSet = dataSet
+        notifyDataSetChanged()
+    }
+
+    override fun getItemId(position: Int): Long {
+        return dataSet[position].id
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        val view =
+            try {
+                LayoutInflater.from(activity).inflate(itemLayoutRes, parent, false)
+            } catch (e: Resources.NotFoundException) {
+                LayoutInflater.from(activity).inflate(R.layout.item_grid_circle, parent, false)
+            }
+        return createViewHolder(view)
+    }
+
+    private fun createViewHolder(view: View): ViewHolder {
+        return ViewHolder(view)
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val artist = dataSet[position]
+        val isChecked = isChecked(artist)
+        holder.itemView.isActivated = isChecked
+        holder.title?.text = artist.name
+        holder.text?.hide()
+        loadArtistImage(artist, holder)
+    }
+
+    private fun setColors(processor: MediaNotificationProcessor, holder: ViewHolder) {
+        holder.mask?.backgroundTintList = ColorStateList.valueOf(processor.primaryTextColor)
+        if (holder.paletteColorContainer != null) {
+            holder.paletteColorContainer?.setBackgroundColor(processor.backgroundColor)
+            holder.title?.setTextColor(processor.primaryTextColor)
+        }
+        holder.imageContainerCard?.setCardBackgroundColor(processor.backgroundColor)
+    }
+
+    private fun loadArtistImage(artist: Artist, holder: ViewHolder) {
+        if (holder.image == null) {
+            return
+        }
+        ArtistGlideRequest.Builder.from(Glide.with(activity), artist)
+            .generatePalette(activity)
+            .build()
+            .into(object : RetroMusicColoredTarget(holder.image!!) {
+                override fun onColorReady(colors: MediaNotificationProcessor) {
+                    setColors(colors, holder)
+                }
+            })
+    }
+
+    override fun getItemCount(): Int {
+        return dataSet.size
+    }
+
+    override fun getIdentifier(position: Int): Artist? {
+        return dataSet[position]
+    }
+
+    override fun getName(artist: Artist): String {
+        return artist.name
+    }
+
+    override fun onMultipleItemAction(
+        menuItem: MenuItem,
+        selection: List<Artist>
+    ) {
+        SongsMenuHelper.handleMenuClick(activity, getSongList(selection), menuItem.itemId)
+    }
+
+    private fun getSongList(artists: List<Artist>): List<Song> {
+        val songs = ArrayList<Song>()
+        for (artist in artists) {
+            songs.addAll(artist.songs) // maybe async in future?
+        }
+        return songs
+    }
+
+    override fun getPopupText(position: Int): String {
+        return getSectionName(position)
+    }
+
+    private fun getSectionName(position: Int): String {
+        return MusicUtil.getSectionName(dataSet[position].name)
+    }
+
+    inner class ViewHolder(itemView: View) : MediaEntryViewHolder(itemView) {
+
+        init {
+            menu?.visibility = View.GONE
+        }
+
+        override fun onClick(v: View?) {
+            super.onClick(v)
+            if (isInQuickSelectMode) {
+                toggleChecked(layoutPosition)
+            } else {
+                image?.let {
+                    ViewCompat.setTransitionName(it, "artist")
+                    IArtistClickListener.onArtist(dataSet[layoutPosition].id, it)
+                }
+            }
+        }
+
+        override fun onLongClick(v: View?): Boolean {
+            toggleChecked(layoutPosition)
+            return super.onLongClick(v)
+        }
+    }
+}

app/src/main/java/code/name/monkey/retromusic/adapter/base/AbsMultiSelectAdapter.java

@@ -0,0 +1,129 @@
+package code.name.monkey.retromusic.adapter.base;
+
+import android.content.Context;
+import android.view.Menu;
+import android.view.MenuItem;
+import androidx.annotation.MenuRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.recyclerview.widget.RecyclerView;
+import code.name.monkey.retromusic.R;
+import code.name.monkey.retromusic.interfaces.ICabHolder;
+import com.afollestad.materialcab.MaterialCab;
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class AbsMultiSelectAdapter<V extends RecyclerView.ViewHolder, I>
+    extends RecyclerView.Adapter<V> implements MaterialCab.Callback {
+
+  @Nullable private final ICabHolder ICabHolder;
+  private final Context context;
+  private MaterialCab cab;
+  private List<I> checked;
+  private int menuRes;
+
+  public AbsMultiSelectAdapter(
+      @NonNull Context context, @Nullable ICabHolder ICabHolder, @MenuRes int menuRes) {
+    this.ICabHolder = ICabHolder;
+    checked = new ArrayList<>();
+    this.menuRes = menuRes;
+    this.context = context;
+  }
+
+  @Override
+  public boolean onCabCreated(MaterialCab materialCab, Menu menu) {
+    return true;
+  }
+
+  @Override
+  public boolean onCabFinished(MaterialCab materialCab) {
+    clearChecked();
+    return true;
+  }
+
+  @Override
+  public boolean onCabItemClicked(MenuItem menuItem) {
+    if (menuItem.getItemId() == R.id.action_multi_select_adapter_check_all) {
+      checkAll();
+    } else {
+      onMultipleItemAction(menuItem, new ArrayList<>(checked));
+      cab.finish();
+      clearChecked();
+    }
+    return true;
+  }
+
+  protected void checkAll() {
+    if (ICabHolder != null) {
+      checked.clear();
+      for (int i = 0; i < getItemCount(); i++) {
+        I identifier = getIdentifier(i);
+        if (identifier != null) {
+          checked.add(identifier);
+        }
+      }
+      notifyDataSetChanged();
+      updateCab();
+    }
+  }
+
+  @Nullable
+  protected abstract I getIdentifier(int position);
+
+  protected String getName(I object) {
+    return object.toString();
+  }
+
+  protected boolean isChecked(I identifier) {
+    return checked.contains(identifier);
+  }
+
+  protected boolean isInQuickSelectMode() {
+    return cab != null && cab.isActive();
+  }
+
+  protected abstract void onMultipleItemAction(MenuItem menuItem, List<I> selection);
+
+  protected void setMultiSelectMenuRes(@MenuRes int menuRes) {
+    this.menuRes = menuRes;
+  }
+
+  protected boolean toggleChecked(final int position) {
+    if (ICabHolder != null) {
+      I identifier = getIdentifier(position);
+      if (identifier == null) {
+        return false;
+      }
+
+      if (!checked.remove(identifier)) {
+        checked.add(identifier);
+      }
+
+      notifyItemChanged(position);
+      updateCab();
+      return true;
+    }
+    return false;
+  }
+
+  private void clearChecked() {
+    checked.clear();
+    notifyDataSetChanged();
+  }
+
+  private void updateCab() {
+    if (ICabHolder != null) {
+      if (cab == null || !cab.isActive()) {
+        cab = ICabHolder.openCab(menuRes, this);
+      }
+      final int size = checked.size();
+      if (size <= 0) {
+        cab.finish();
+      } else if (size == 1) {
+        cab.setTitle(getName(checked.get(0)));
+      } else {
+        cab.setTitle(context.getString(R.string.x_selected, size));
+      }
+    }
+  }
+}

app/src/main/java/code/name/monkey/retromusic/adapter/base/MediaEntryViewHolder.java

@@ -0,0 +1,137 @@
+/*
+ * 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.adapter.base;
+
+import android.graphics.Color;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.widget.AppCompatImageView;
+import androidx.recyclerview.widget.RecyclerView;
+
+import code.name.monkey.retromusic.R;
+
+import com.google.android.material.card.MaterialCardView;
+import com.h6ah4i.android.widget.advrecyclerview.utils.AbstractDraggableSwipeableItemViewHolder;
+
+public class MediaEntryViewHolder extends AbstractDraggableSwipeableItemViewHolder
+        implements View.OnLongClickListener, View.OnClickListener {
+
+    @Nullable
+    public View dragView;
+
+    @Nullable
+    public View dummyContainer;
+
+    @Nullable
+    public ImageView image;
+
+    @Nullable
+    public ImageView artistImage;
+
+    @Nullable
+    public ImageView playerImage;
+
+    @Nullable
+    public MaterialCardView imageContainerCard;
+
+    @Nullable
+    public TextView imageText;
+
+    @Nullable
+    public MaterialCardView imageTextContainer;
+
+    @Nullable
+    public View mask;
+
+    @Nullable
+    public AppCompatImageView menu;
+
+    @Nullable
+    public View paletteColorContainer;
+
+
+    @Nullable
+    public RecyclerView recyclerView;
+
+    @Nullable
+    public TextView text;
+
+    @Nullable
+    public TextView text2;
+
+    @Nullable
+    public TextView time;
+
+    @Nullable
+    public TextView title;
+
+    public MediaEntryViewHolder(@NonNull View itemView) {
+        super(itemView);
+        title = itemView.findViewById(R.id.title);
+        text = itemView.findViewById(R.id.text);
+        text2 = itemView.findViewById(R.id.text2);
+
+        image = itemView.findViewById(R.id.image);
+        artistImage = itemView.findViewById(R.id.artistImage);
+        playerImage = itemView.findViewById(R.id.player_image);
+        time = itemView.findViewById(R.id.time);
+
+        imageText = itemView.findViewById(R.id.imageText);
+        imageTextContainer = itemView.findViewById(R.id.imageTextContainer);
+        imageContainerCard = itemView.findViewById(R.id.imageContainerCard);
+
+        menu = itemView.findViewById(R.id.menu);
+        dragView = itemView.findViewById(R.id.drag_view);
+        paletteColorContainer = itemView.findViewById(R.id.paletteColorContainer);
+        recyclerView = itemView.findViewById(R.id.recycler_view);
+        mask = itemView.findViewById(R.id.mask);
+        dummyContainer = itemView.findViewById(R.id.dummy_view);
+
+        if (imageContainerCard != null) {
+            imageContainerCard.setCardBackgroundColor(Color.TRANSPARENT);
+        }
+        itemView.setOnClickListener(this);
+        itemView.setOnLongClickListener(this);
+    }
+
+    @Nullable
+    @Override
+    public View getSwipeableContainerView() {
+        return null;
+    }
+
+    @Override
+    public void onClick(View v) {
+    }
+
+    @Override
+    public boolean onLongClick(View v) {
+        return false;
+    }
+
+    public void setImageTransitionName(@NonNull String transitionName) {
+        itemView.setTransitionName(transitionName);
+    /* if (imageContainerCard != null) {
+        imageContainerCard.setTransitionName(transitionName);
+    }
+    if (image != null) {
+        image.setTransitionName(transitionName);
+    }*/
+    }
+}

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

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter.playlist
+
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.FragmentActivity
+import androidx.recyclerview.widget.RecyclerView
+import code.name.monkey.retromusic.adapter.base.MediaEntryViewHolder
+import code.name.monkey.retromusic.model.Playlist
+import code.name.monkey.retromusic.util.MusicUtil
+
+class LegacyPlaylistAdapter(
+    private val activity: FragmentActivity,
+    private var list: List<Playlist>,
+    private val layoutRes: Int,
+    private val playlistClickListener: PlaylistClickListener
+) :
+    RecyclerView.Adapter<LegacyPlaylistAdapter.ViewHolder>() {
+
+    fun swapData(list: List<Playlist>) {
+        this.list = list
+        notifyDataSetChanged()
+    }
+
+    class ViewHolder(itemView: View) : MediaEntryViewHolder(itemView)
+
+    override fun onCreateViewHolder(
+        parent: ViewGroup,
+        viewType: Int
+    ): ViewHolder {
+        return ViewHolder(
+            LayoutInflater.from(parent.context).inflate(layoutRes, parent, false)
+        )
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val playlist: Playlist = list[position]
+        holder.title?.text = playlist.name
+        holder.text?.text = MusicUtil.getPlaylistInfoString(activity, playlist.getSongs())
+        holder.itemView.setOnClickListener {
+            playlistClickListener.onPlaylistClick(playlist)
+        }
+    }
+
+    override fun getItemCount(): Int {
+        return list.size
+    }
+
+    interface PlaylistClickListener {
+        fun onPlaylistClick(playlist: Playlist)
+    }
+}

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

@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter.playlist
+
+import android.graphics.Color
+import android.graphics.drawable.Drawable
+import android.text.TextUtils
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import androidx.appcompat.widget.PopupMenu
+import androidx.core.view.ViewCompat
+import androidx.fragment.app.FragmentActivity
+import androidx.lifecycle.lifecycleScope
+import code.name.monkey.appthemehelper.util.ATHUtil
+import code.name.monkey.appthemehelper.util.TintHelper
+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.db.PlaylistEntity
+import code.name.monkey.retromusic.db.PlaylistWithSongs
+import code.name.monkey.retromusic.db.SongEntity
+import code.name.monkey.retromusic.db.toSongs
+import code.name.monkey.retromusic.extensions.hide
+import code.name.monkey.retromusic.extensions.show
+import code.name.monkey.retromusic.helper.menu.PlaylistMenuHelper
+import code.name.monkey.retromusic.helper.menu.SongsMenuHelper
+import code.name.monkey.retromusic.interfaces.ICabHolder
+import code.name.monkey.retromusic.interfaces.IPlaylistClickListener
+import code.name.monkey.retromusic.model.Song
+import code.name.monkey.retromusic.util.AutoGeneratedPlaylistBitmap
+import code.name.monkey.retromusic.util.MusicUtil
+import kotlinx.coroutines.Dispatchers.IO
+import kotlinx.coroutines.Dispatchers.Main
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+class PlaylistAdapter(
+    private val activity: FragmentActivity,
+    private var dataSet: List<PlaylistWithSongs>,
+    private var itemLayoutRes: Int,
+    ICabHolder: ICabHolder?,
+    private val listener: IPlaylistClickListener
+) : AbsMultiSelectAdapter<PlaylistAdapter.ViewHolder, PlaylistWithSongs>(
+    activity,
+    ICabHolder,
+    R.menu.menu_playlists_selection
+) {
+
+    init {
+        setHasStableIds(true)
+    }
+
+    fun swapDataSet(dataSet: List<PlaylistWithSongs>) {
+        this.dataSet = dataSet
+        notifyDataSetChanged()
+    }
+
+    override fun getItemId(position: Int): Long {
+        return dataSet[position].playlistEntity.playListId
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        val view = LayoutInflater.from(activity).inflate(itemLayoutRes, parent, false)
+        return createViewHolder(view)
+    }
+
+    fun createViewHolder(view: View): ViewHolder {
+        return ViewHolder(view)
+    }
+
+    private fun getPlaylistTitle(playlist: PlaylistEntity): String {
+        return if (TextUtils.isEmpty(playlist.playlistName)) "-" else playlist.playlistName
+    }
+
+    private fun getPlaylistText(playlist: PlaylistWithSongs): String {
+        return MusicUtil.getPlaylistInfoString(activity, playlist.songs.toSongs())
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val playlist = dataSet[position]
+        holder.itemView.isActivated = isChecked(playlist)
+        holder.title?.text = getPlaylistTitle(playlist.playlistEntity)
+        holder.text?.text = getPlaylistText(playlist)
+        holder.image?.setImageDrawable(getIconRes())
+        val isChecked = isChecked(playlist)
+        if (isChecked) {
+            holder.menu?.hide()
+        } else {
+            holder.menu?.show()
+        }
+        //playlistBitmapLoader(activity, holder, playlist)
+    }
+
+    private fun getIconRes(): Drawable = TintHelper.createTintedDrawable(
+        activity,
+        R.drawable.ic_playlist_play,
+        ATHUtil.resolveColor(activity, R.attr.colorControlNormal)
+    )
+
+    override fun getItemCount(): Int {
+        return dataSet.size
+    }
+
+    override fun getIdentifier(position: Int): PlaylistWithSongs? {
+        return dataSet[position]
+    }
+
+    override fun getName(playlist: PlaylistWithSongs): String {
+        return playlist.playlistEntity.playlistName
+    }
+
+    override fun onMultipleItemAction(menuItem: MenuItem, selection: List<PlaylistWithSongs>) {
+        when (menuItem.itemId) {
+            else -> SongsMenuHelper.handleMenuClick(
+                activity,
+                getSongList(selection),
+                menuItem.itemId
+            )
+        }
+    }
+
+    private fun getSongList(playlists: List<PlaylistWithSongs>): List<Song> {
+        val songs = mutableListOf<Song>()
+        playlists.forEach {
+            songs.addAll(it.songs.toSongs())
+        }
+        return songs
+    }
+
+    private fun getSongs(playlist: PlaylistWithSongs): List<SongEntity> =
+        mutableListOf<SongEntity>().apply {
+            addAll(playlist.songs)
+        }
+
+    inner class ViewHolder(itemView: View) : MediaEntryViewHolder(itemView) {
+        init {
+            image?.apply {
+                val iconPadding =
+                    activity.resources.getDimensionPixelSize(R.dimen.list_item_image_icon_padding)
+                setPadding(iconPadding, iconPadding, iconPadding, iconPadding)
+            }
+            menu?.setOnClickListener { view ->
+                val popupMenu = PopupMenu(activity, view)
+                popupMenu.inflate(R.menu.menu_item_playlist)
+                popupMenu.setOnMenuItemClickListener { item ->
+                    PlaylistMenuHelper.handleMenuClick(activity, dataSet[layoutPosition], item)
+                }
+                popupMenu.show()
+            }
+
+            imageTextContainer?.apply {
+                cardElevation = 0f
+                setCardBackgroundColor(Color.TRANSPARENT)
+            }
+        }
+
+        override fun onClick(v: View?) {
+            if (isInQuickSelectMode) {
+                toggleChecked(layoutPosition)
+            } else {
+                ViewCompat.setTransitionName(itemView, "playlist")
+                listener.onPlaylistClick(dataSet[layoutPosition], itemView)
+            }
+        }
+
+        override fun onLongClick(v: View?): Boolean {
+            toggleChecked(layoutPosition)
+            return true
+        }
+    }
+
+    private fun playlistBitmapLoader(
+        activity: FragmentActivity,
+        viewHolder: ViewHolder,
+        playlist: PlaylistWithSongs
+    ) {
+
+        activity.lifecycleScope.launch(IO) {
+            val songs = playlist.songs.toSongs()
+            val bitmap = AutoGeneratedPlaylistBitmap.getBitmap(activity, songs, false, false)
+            withContext(Main) { viewHolder.image?.setImageBitmap(bitmap) }
+        }
+
+        /*
+          override fun doInBackground(vararg params: Void?): Bitmap {
+              val songs = playlist.songs.toSongs()
+              return AutoGeneratedPlaylistBitmap.getBitmap(activity, songs, false, false)
+          }
+
+          override fun onPostExecute(result: Bitmap?) {
+              super.onPostExecute(result)
+              viewHolder.image?.setImageBitmap(result)
+              val color = RetroColorUtil.getColor(
+                  RetroColorUtil.generatePalette(
+                      result
+                  ),
+                  ATHUtil.resolveColor(activity, R.attr.colorSurface)
+              )
+              viewHolder.paletteColorContainer?.setBackgroundColor(color)
+          }*/
+    }
+
+    companion object {
+        val TAG: String = PlaylistAdapter::class.java.simpleName
+    }
+}

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

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter.song
+
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.annotation.LayoutRes
+import androidx.fragment.app.FragmentActivity
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.helper.MusicPlayerRemote
+import code.name.monkey.retromusic.interfaces.ICabHolder
+import code.name.monkey.retromusic.model.Song
+
+abstract class AbsOffsetSongAdapter(
+    activity: FragmentActivity,
+    dataSet: MutableList<Song>,
+    @LayoutRes itemLayoutRes: Int,
+    ICabHolder: ICabHolder?
+) : SongAdapter(activity, dataSet, itemLayoutRes, ICabHolder) {
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): SongAdapter.ViewHolder {
+        if (viewType == OFFSET_ITEM) {
+            val view = LayoutInflater.from(activity)
+                .inflate(R.layout.item_list_quick_actions, parent, false)
+            return createViewHolder(view)
+        }
+        return super.onCreateViewHolder(parent, viewType)
+    }
+
+    override fun createViewHolder(view: View): SongAdapter.ViewHolder {
+        return ViewHolder(view)
+    }
+
+    override fun getItemId(position: Int): Long {
+        var positionFinal = position
+        positionFinal--
+        return if (positionFinal < 0) -2 else super.getItemId(positionFinal)
+    }
+
+    override fun getIdentifier(position: Int): Song? {
+        var positionFinal = position
+        positionFinal--
+        return if (positionFinal < 0) null else super.getIdentifier(positionFinal)
+    }
+
+    override fun getItemCount(): Int {
+        val superItemCount = super.getItemCount()
+        return if (superItemCount == 0) 0 else superItemCount + 1
+    }
+
+    override fun getItemViewType(position: Int): Int {
+        return if (position == 0) OFFSET_ITEM else SONG
+    }
+
+    open inner class ViewHolder(itemView: View) : SongAdapter.ViewHolder(itemView) {
+
+        override // could also return null, just to be safe return empty song
+        val song: Song
+            get() = if (itemViewType == OFFSET_ITEM) Song.emptySong else dataSet[layoutPosition - 1]
+
+        override fun onClick(v: View?) {
+            if (isInQuickSelectMode && itemViewType != OFFSET_ITEM) {
+                toggleChecked(layoutPosition)
+            } else {
+                MusicPlayerRemote.openQueue(dataSet, layoutPosition - 1, true)
+            }
+        }
+
+        override fun onLongClick(v: View?): Boolean {
+            if (itemViewType == OFFSET_ITEM) return false
+            toggleChecked(layoutPosition)
+            return true
+        }
+    }
+
+    companion object {
+        const val OFFSET_ITEM = 0
+        const val SONG = 1
+    }
+}

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

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter.song
+
+import android.view.MenuItem
+import android.view.View
+import androidx.fragment.app.FragmentActivity
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.R.menu
+import code.name.monkey.retromusic.db.PlaylistEntity
+import code.name.monkey.retromusic.db.toSongEntity
+import code.name.monkey.retromusic.db.toSongs
+import code.name.monkey.retromusic.dialogs.RemoveSongFromPlaylistDialog
+import code.name.monkey.retromusic.interfaces.ICabHolder
+import code.name.monkey.retromusic.model.PlaylistSong
+import code.name.monkey.retromusic.model.Song
+import code.name.monkey.retromusic.util.ViewUtil
+import com.h6ah4i.android.widget.advrecyclerview.draggable.DraggableItemAdapter
+import com.h6ah4i.android.widget.advrecyclerview.draggable.DraggableItemViewHolder
+import com.h6ah4i.android.widget.advrecyclerview.draggable.ItemDraggableRange
+import com.h6ah4i.android.widget.advrecyclerview.draggable.annotation.DraggableItemStateFlags
+
+class OrderablePlaylistSongAdapter(
+    private val playlist: PlaylistEntity,
+    activity: FragmentActivity,
+    dataSet: ArrayList<Song>,
+    itemLayoutRes: Int,
+    ICabHolder: ICabHolder?,
+    private val onMoveItemListener: OnMoveItemListener?
+) : SongAdapter(
+    activity,
+    dataSet,
+    itemLayoutRes,
+    ICabHolder
+), DraggableItemAdapter<OrderablePlaylistSongAdapter.ViewHolder> {
+
+    init {
+        setMultiSelectMenuRes(menu.menu_playlists_songs_selection)
+    }
+
+    override fun createViewHolder(view: View): SongAdapter.ViewHolder {
+        return ViewHolder(view)
+    }
+
+    override fun getItemId(position: Int): Long {
+        var positionFinal = position
+        positionFinal--
+
+        var long: Long = 0
+        if (positionFinal < 0) {
+            long = -2
+        } else {
+            if (dataSet[positionFinal] is PlaylistSong) {
+                long = (dataSet[positionFinal] as PlaylistSong).idInPlayList.toLong()
+            }
+        }
+        return long
+    }
+
+    override fun onMultipleItemAction(menuItem: MenuItem, selection: List<Song>) {
+        when (menuItem.itemId) {
+            R.id.action_remove_from_playlist -> {
+                RemoveSongFromPlaylistDialog.create(selection.toSongs(playlist.playListId))
+                    .show(activity.supportFragmentManager, "REMOVE_FROM_PLAYLIST")
+                return
+            }
+        }
+        super.onMultipleItemAction(menuItem, selection)
+    }
+
+    override fun onCheckCanStartDrag(holder: ViewHolder, position: Int, x: Int, y: Int): Boolean {
+        return onMoveItemListener != null && position > 0 && (ViewUtil.hitTest(
+            holder.dragView!!, x, y
+        ) || ViewUtil.hitTest(holder.image!!, x, y))
+    }
+
+    override fun onGetItemDraggableRange(holder: ViewHolder, position: Int): ItemDraggableRange {
+        return ItemDraggableRange(1, dataSet.size)
+    }
+
+    override fun onMoveItem(fromPosition: Int, toPosition: Int) {
+        if (onMoveItemListener != null && fromPosition != toPosition) {
+            onMoveItemListener.onMoveItem(fromPosition - 1, toPosition - 1)
+        }
+    }
+
+    override fun onCheckCanDrop(draggingPosition: Int, dropPosition: Int): Boolean {
+        return dropPosition > 0
+    }
+
+    override fun onItemDragStarted(position: Int) {
+        notifyDataSetChanged()
+    }
+
+    override fun onItemDragFinished(fromPosition: Int, toPosition: Int, result: Boolean) {
+        notifyDataSetChanged()
+    }
+
+    interface OnMoveItemListener {
+        fun onMoveItem(fromPosition: Int, toPosition: Int)
+    }
+
+    inner class ViewHolder(itemView: View) : SongAdapter.ViewHolder(itemView),
+        DraggableItemViewHolder {
+        @DraggableItemStateFlags
+        private var mDragStateFlags: Int = 0
+
+        override var songMenuRes: Int
+            get() = R.menu.menu_item_playlist_song
+            set(value) {
+                super.songMenuRes = value
+            }
+
+        init {
+            if (dragView != null) {
+                if (onMoveItemListener != null) {
+                    dragView?.visibility = View.VISIBLE
+                } else {
+                    dragView?.visibility = View.GONE
+                }
+            }
+        }
+
+        override fun onSongMenuItemClick(item: MenuItem): Boolean {
+            when (item.itemId) {
+                R.id.action_remove_from_playlist -> {
+                    RemoveSongFromPlaylistDialog.create(song.toSongEntity(playlist.playListId))
+                        .show(activity.supportFragmentManager, "REMOVE_FROM_PLAYLIST")
+                    return true
+                }
+            }
+            return super.onSongMenuItemClick(item)
+        }
+
+        @DraggableItemStateFlags
+        override fun getDragStateFlags(): Int {
+            return mDragStateFlags
+        }
+
+        override fun setDragStateFlags(@DraggableItemStateFlags flags: Int) {
+            mDragStateFlags = flags
+        }
+    }
+}

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

@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter.song
+
+import android.view.MenuItem
+import android.view.View
+import androidx.appcompat.app.AppCompatActivity
+import androidx.fragment.app.FragmentActivity
+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.helper.MusicPlayerRemote.isPlaying
+import code.name.monkey.retromusic.helper.MusicPlayerRemote.playNextSong
+import code.name.monkey.retromusic.helper.MusicPlayerRemote.removeFromQueue
+import code.name.monkey.retromusic.model.Song
+import code.name.monkey.retromusic.util.MusicUtil
+import code.name.monkey.retromusic.util.ViewUtil
+import code.name.monkey.retromusic.util.color.MediaNotificationProcessor
+import com.bumptech.glide.Glide
+import com.h6ah4i.android.widget.advrecyclerview.draggable.DraggableItemAdapter
+import com.h6ah4i.android.widget.advrecyclerview.draggable.ItemDraggableRange
+import com.h6ah4i.android.widget.advrecyclerview.draggable.annotation.DraggableItemStateFlags
+import com.h6ah4i.android.widget.advrecyclerview.swipeable.SwipeableItemAdapter
+import com.h6ah4i.android.widget.advrecyclerview.swipeable.SwipeableItemConstants
+import com.h6ah4i.android.widget.advrecyclerview.swipeable.action.SwipeResultAction
+import com.h6ah4i.android.widget.advrecyclerview.swipeable.action.SwipeResultActionDefault
+import com.h6ah4i.android.widget.advrecyclerview.swipeable.action.SwipeResultActionRemoveItem
+import me.zhanghai.android.fastscroll.PopupTextProvider
+
+class PlayingQueueAdapter(
+    activity: AppCompatActivity,
+    dataSet: MutableList<Song>,
+    private var current: Int,
+    itemLayoutRes: Int
+) : SongAdapter(
+    activity, dataSet, itemLayoutRes, null
+), DraggableItemAdapter<PlayingQueueAdapter.ViewHolder>,
+    SwipeableItemAdapter<PlayingQueueAdapter.ViewHolder>,
+    PopupTextProvider {
+
+    private var songToRemove: Song? = null
+
+    override fun createViewHolder(view: View): SongAdapter.ViewHolder {
+        return ViewHolder(view)
+    }
+
+    override fun onBindViewHolder(holder: SongAdapter.ViewHolder, position: Int) {
+        super.onBindViewHolder(holder, position)
+        val song = dataSet[position]
+        holder.time?.text = MusicUtil.getReadableDurationString(song.duration)
+        if (holder.itemViewType == HISTORY || holder.itemViewType == CURRENT) {
+            setAlpha(holder, 0.5f)
+        }
+    }
+
+    override fun getItemViewType(position: Int): Int {
+        if (position < current) {
+            return HISTORY
+        } else if (position > current) {
+            return UP_NEXT
+        }
+        return CURRENT
+    }
+
+    override fun loadAlbumCover(song: Song, holder: SongAdapter.ViewHolder) {
+        if (holder.image == null) {
+            return
+        }
+        SongGlideRequest.Builder.from(Glide.with(activity), song)
+            .checkIgnoreMediaStore(activity)
+            .generatePalette(activity).build()
+            .into(object : RetroMusicColoredTarget(holder.image!!) {
+                override fun onColorReady(colors: MediaNotificationProcessor) {
+                    //setColors(colors, holder)
+                }
+            })
+    }
+
+    fun swapDataSet(dataSet: List<Song>, position: Int) {
+        this.dataSet = dataSet.toMutableList()
+        current = position
+        notifyDataSetChanged()
+    }
+
+    fun setCurrent(current: Int) {
+        this.current = current
+        notifyDataSetChanged()
+    }
+
+    private fun setAlpha(holder: SongAdapter.ViewHolder, alpha: Float) {
+        holder.image?.alpha = alpha
+        holder.title?.alpha = alpha
+        holder.text?.alpha = alpha
+        holder.paletteColorContainer?.alpha = alpha
+        holder.dragView?.alpha = alpha
+        holder.menu?.alpha = alpha
+    }
+
+    override fun getPopupText(position: Int): String {
+        return MusicUtil.getSectionName(dataSet[position].title)
+    }
+
+    override fun onCheckCanStartDrag(holder: ViewHolder, position: Int, x: Int, y: Int): Boolean {
+        return ViewUtil.hitTest(holder.imageText!!, x, y) || ViewUtil.hitTest(
+            holder.dragView!!,
+            x,
+            y
+        )
+    }
+
+    override fun onGetItemDraggableRange(holder: ViewHolder, position: Int): ItemDraggableRange? {
+        return null
+    }
+
+    override fun onMoveItem(fromPosition: Int, toPosition: Int) {
+        MusicPlayerRemote.moveSong(fromPosition, toPosition)
+    }
+
+    override fun onCheckCanDrop(draggingPosition: Int, dropPosition: Int): Boolean {
+        return true
+    }
+
+    override fun onItemDragStarted(position: Int) {
+        notifyDataSetChanged()
+    }
+
+    override fun onItemDragFinished(fromPosition: Int, toPosition: Int, result: Boolean) {
+        notifyDataSetChanged()
+    }
+
+    fun setSongToRemove(song: Song) {
+        songToRemove = song
+    }
+
+    inner class ViewHolder(itemView: View) : SongAdapter.ViewHolder(itemView) {
+        @DraggableItemStateFlags
+        private var mDragStateFlags: Int = 0
+
+        override var songMenuRes: Int
+            get() = R.menu.menu_item_playing_queue_song
+            set(value) {
+                super.songMenuRes = value
+            }
+
+        init {
+            dragView?.visibility = View.VISIBLE
+        }
+
+        override fun onSongMenuItemClick(item: MenuItem): Boolean {
+            when (item.itemId) {
+                R.id.action_remove_from_playing_queue -> {
+                    removeFromQueue(layoutPosition)
+                    return true
+                }
+            }
+            return super.onSongMenuItemClick(item)
+        }
+
+        @DraggableItemStateFlags
+        override fun getDragStateFlags(): Int {
+            return mDragStateFlags
+        }
+
+        override fun setDragStateFlags(@DraggableItemStateFlags flags: Int) {
+            mDragStateFlags = flags
+        }
+
+        override fun getSwipeableContainerView(): View {
+            return dummyContainer!!
+        }
+    }
+
+    companion object {
+
+        private const val HISTORY = 0
+        private const val CURRENT = 1
+        private const val UP_NEXT = 2
+    }
+
+    override fun onSwipeItem(holder: ViewHolder, position: Int, result: Int): SwipeResultAction? {
+        return if (result == SwipeableItemConstants.RESULT_CANCELED) {
+            SwipeResultActionDefault()
+        } else {
+            SwipedResultActionRemoveItem(this, position, activity)
+        }
+    }
+
+    override fun onGetSwipeReactionType(holder: ViewHolder, position: Int, x: Int, y: Int): Int {
+        return if (onCheckCanStartDrag(holder, position, x, y)) {
+            SwipeableItemConstants.REACTION_CAN_NOT_SWIPE_BOTH_H
+        } else {
+            SwipeableItemConstants.REACTION_CAN_SWIPE_BOTH_H
+        }
+    }
+
+    override fun onSwipeItemStarted(holder: ViewHolder, p1: Int) {
+    }
+
+    override fun onSetSwipeBackground(holder: ViewHolder, position: Int, result: Int) {
+    }
+
+    internal class SwipedResultActionRemoveItem(
+        private val adapter: PlayingQueueAdapter,
+        private val position: Int,
+        private val activity: FragmentActivity
+    ) : SwipeResultActionRemoveItem() {
+
+        private var songToRemove: Song? = null
+        private val isPlaying: Boolean = MusicPlayerRemote.isPlaying
+        private val songProgressMillis = 0
+        override fun onPerformAction() {
+            // currentlyShownSnackbar = null
+        }
+
+        override fun onSlideAnimationEnd() {
+            // initializeSnackBar(adapter, position, activity, isPlaying)
+            songToRemove = adapter.dataSet[position]
+            // If song removed was the playing song, then play the next song
+            if (isPlaying(songToRemove!!)) {
+                playNextSong()
+            }
+            // Swipe animation is much smoother when we do the heavy lifting after it's completed
+            adapter.setSongToRemove(songToRemove!!)
+            removeFromQueue(songToRemove!!)
+        }
+    }
+}

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

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter.song
+
+import android.view.MenuItem
+import android.view.View
+import androidx.fragment.app.FragmentActivity
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.db.PlaylistEntity
+import code.name.monkey.retromusic.db.toSongEntity
+import code.name.monkey.retromusic.dialogs.RemoveSongFromPlaylistDialog
+import code.name.monkey.retromusic.interfaces.ICabHolder
+import code.name.monkey.retromusic.model.Song
+
+class PlaylistSongAdapter(
+    private val playlist: PlaylistEntity,
+    activity: FragmentActivity,
+    dataSet: MutableList<Song>,
+    itemLayoutRes: Int,
+    iCabHolder: ICabHolder?
+) : SongAdapter(activity, dataSet, itemLayoutRes, iCabHolder) {
+
+    init {
+        this.setMultiSelectMenuRes(R.menu.menu_cannot_delete_single_songs_playlist_songs_selection)
+    }
+
+    override fun createViewHolder(view: View): SongAdapter.ViewHolder {
+        return ViewHolder(view)
+    }
+
+    open inner class ViewHolder(itemView: View) : SongAdapter.ViewHolder(itemView) {
+
+        override var songMenuRes: Int
+            get() = R.menu.menu_item_playlist_song
+            set(value) {
+                super.songMenuRes = value
+            }
+
+        override fun onSongMenuItemClick(item: MenuItem): Boolean {
+            when (item.itemId) {
+                R.id.action_remove_from_playlist -> {
+                    RemoveSongFromPlaylistDialog.create(song.toSongEntity(playlist.playListId))
+                        .show(activity.supportFragmentManager, "REMOVE_FROM_PLAYLIST")
+                    return true
+                }
+            }
+            return super.onSongMenuItemClick(item)
+        }
+    }
+}

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

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter.song
+
+import android.view.View
+import androidx.fragment.app.FragmentActivity
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.extensions.applyColor
+import code.name.monkey.retromusic.extensions.applyOutlineColor
+import code.name.monkey.retromusic.helper.MusicPlayerRemote
+import code.name.monkey.retromusic.interfaces.ICabHolder
+import code.name.monkey.retromusic.model.Song
+import com.google.android.material.button.MaterialButton
+
+class ShuffleButtonSongAdapter(
+    activity: FragmentActivity,
+    dataSet: MutableList<Song>,
+    itemLayoutRes: Int,
+    ICabHolder: ICabHolder?
+) : AbsOffsetSongAdapter(activity, dataSet, itemLayoutRes, ICabHolder) {
+
+    override fun createViewHolder(view: View): SongAdapter.ViewHolder {
+        return ViewHolder(view)
+    }
+
+    override fun onBindViewHolder(holder: SongAdapter.ViewHolder, position: Int) {
+        if (holder.itemViewType == OFFSET_ITEM) {
+            val color = ThemeStore.accentColor(activity)
+            val viewHolder = holder as ViewHolder
+            viewHolder.playAction?.let {
+                it.setOnClickListener {
+                    MusicPlayerRemote.openQueue(dataSet, 0, true)
+                }
+                it.applyOutlineColor(color)
+            }
+            viewHolder.shuffleAction?.let {
+                it.setOnClickListener {
+                    MusicPlayerRemote.openAndShuffleQueue(dataSet, true)
+                }
+                it.applyColor(color)
+            }
+        } else {
+            super.onBindViewHolder(holder, position - 1)
+        }
+    }
+
+    inner class ViewHolder(itemView: View) : AbsOffsetSongAdapter.ViewHolder(itemView) {
+        val playAction: MaterialButton? = itemView.findViewById(R.id.playAction)
+        val shuffleAction: MaterialButton? = itemView.findViewById(R.id.shuffleAction)
+
+        override fun onClick(v: View?) {
+            if (itemViewType == OFFSET_ITEM) {
+                MusicPlayerRemote.openAndShuffleQueue(dataSet, true)
+                return
+            }
+            super.onClick(v)
+        }
+    }
+}

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

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter.song
+
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.FragmentActivity
+import code.name.monkey.retromusic.interfaces.ICabHolder
+import code.name.monkey.retromusic.model.Song
+import code.name.monkey.retromusic.util.MusicUtil
+import java.util.*
+
+class SimpleSongAdapter(
+    context: FragmentActivity,
+    songs: ArrayList<Song>,
+    layoutRes: Int,
+    ICabHolder: ICabHolder?
+) : SongAdapter(context, songs, layoutRes, ICabHolder) {
+
+    override fun swapDataSet(dataSet: List<Song>) {
+        this.dataSet = dataSet.toMutableList()
+        notifyDataSetChanged()
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        return ViewHolder(LayoutInflater.from(activity).inflate(itemLayoutRes, parent, false))
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        super.onBindViewHolder(holder, position)
+        val fixedTrackNumber = MusicUtil.getFixedTrackNumber(dataSet[position].trackNumber)
+        val trackAndTime = (if (fixedTrackNumber > 0) "$fixedTrackNumber | " else "") +
+                MusicUtil.getReadableDurationString(dataSet[position].duration)
+
+        holder.imageText?.visibility = View.GONE
+        holder.time?.text = trackAndTime
+        holder.text2?.text = dataSet[position].artistName
+    }
+
+    override fun getItemCount(): Int {
+        return dataSet.size
+    }
+}

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

@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.adapter.song
+
+import android.content.res.ColorStateList
+import android.content.res.Resources
+import android.view.LayoutInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.os.bundleOf
+import androidx.core.view.isVisible
+import androidx.fragment.app.FragmentActivity
+import androidx.navigation.findNavController
+import code.name.monkey.retromusic.EXTRA_ALBUM_ID
+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.extensions.hide
+import code.name.monkey.retromusic.extensions.show
+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.SongMenuHelper
+import code.name.monkey.retromusic.helper.menu.SongsMenuHelper
+import code.name.monkey.retromusic.interfaces.ICabHolder
+import code.name.monkey.retromusic.model.Song
+import code.name.monkey.retromusic.util.MusicUtil
+import code.name.monkey.retromusic.util.PreferenceUtil
+import code.name.monkey.retromusic.util.color.MediaNotificationProcessor
+import com.afollestad.materialcab.MaterialCab
+import com.bumptech.glide.Glide
+import me.zhanghai.android.fastscroll.PopupTextProvider
+
+/**
+ * Created by hemanths on 13/08/17.
+ */
+
+open class SongAdapter(
+    protected val activity: FragmentActivity,
+    var dataSet: MutableList<Song>,
+    protected var itemLayoutRes: Int,
+    ICabHolder: ICabHolder?,
+    showSectionName: Boolean = true
+) : AbsMultiSelectAdapter<SongAdapter.ViewHolder, Song>(
+    activity,
+    ICabHolder,
+    R.menu.menu_media_selection
+), MaterialCab.Callback, PopupTextProvider {
+
+    private var showSectionName = true
+
+    init {
+        this.showSectionName = showSectionName
+        this.setHasStableIds(true)
+    }
+
+    open fun swapDataSet(dataSet: List<Song>) {
+        this.dataSet = ArrayList(dataSet)
+        notifyDataSetChanged()
+    }
+
+    override fun getItemId(position: Int): Long {
+        return dataSet[position].id
+    }
+
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
+        val view =
+            try {
+                LayoutInflater.from(activity).inflate(itemLayoutRes, parent, false)
+            } catch (e: Resources.NotFoundException) {
+                LayoutInflater.from(activity).inflate(R.layout.item_list, parent, false)
+            }
+        return createViewHolder(view)
+    }
+
+    protected open fun createViewHolder(view: View): ViewHolder {
+        return ViewHolder(view)
+    }
+
+    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
+        val song = dataSet[position]
+        val isChecked = isChecked(song)
+        holder.itemView.isActivated = isChecked
+        if (isChecked) {
+            holder.menu?.hide()
+        } else {
+            holder.menu?.show()
+        }
+        holder.title?.text = getSongTitle(song)
+        holder.text?.text = getSongText(song)
+        holder.text2?.text = getSongText(song)
+        loadAlbumCover(song, holder)
+    }
+
+    private fun setColors(color: MediaNotificationProcessor, holder: ViewHolder) {
+        if (holder.paletteColorContainer != null) {
+            holder.title?.setTextColor(color.primaryTextColor)
+            holder.text?.setTextColor(color.secondaryTextColor)
+            holder.paletteColorContainer?.setBackgroundColor(color.backgroundColor)
+            holder.menu?.imageTintList= ColorStateList.valueOf(color.primaryTextColor)
+        }
+        holder.mask?.backgroundTintList = ColorStateList.valueOf(color.primaryTextColor)
+    }
+
+    protected open fun loadAlbumCover(song: Song, holder: ViewHolder) {
+        if (holder.image == null) {
+            return
+        }
+        SongGlideRequest.Builder.from(Glide.with(activity), song)
+            .checkIgnoreMediaStore(activity)
+            .generatePalette(activity).build()
+            .into(object : RetroMusicColoredTarget(holder.image!!) {
+                override fun onColorReady(colors: MediaNotificationProcessor) {
+                    setColors(colors, holder)
+                }
+            })
+    }
+
+    private fun getSongTitle(song: Song): String? {
+        return song.title
+    }
+
+    private fun getSongText(song: Song): String? {
+        return song.artistName
+    }
+
+    private fun getSongText2(song: Song): String? {
+        return song.albumName
+    }
+
+    override fun getItemCount(): Int {
+        return dataSet.size
+    }
+
+    override fun getIdentifier(position: Int): Song? {
+        return dataSet[position]
+    }
+
+    override fun getName(song: Song): String {
+        return song.title
+    }
+
+    override fun onMultipleItemAction(menuItem: MenuItem, selection: List<Song>) {
+        SongsMenuHelper.handleMenuClick(activity, selection, menuItem.itemId)
+    }
+
+    override fun getPopupText(position: Int): String {
+        val sectionName: String? = when (PreferenceUtil.songSortOrder) {
+            SortOrder.SongSortOrder.SONG_A_Z, SortOrder.SongSortOrder.SONG_Z_A -> dataSet[position].title
+            SortOrder.SongSortOrder.SONG_ALBUM -> dataSet[position].albumName
+            SortOrder.SongSortOrder.SONG_ARTIST -> dataSet[position].artistName
+            SortOrder.SongSortOrder.SONG_YEAR -> return MusicUtil.getYearString(dataSet[position].year)
+            SortOrder.SongSortOrder.COMPOSER -> dataSet[position].composer
+            else -> {
+                return ""
+            }
+        }
+        return MusicUtil.getSectionName(sectionName)
+    }
+
+    open inner class ViewHolder(itemView: View) : MediaEntryViewHolder(itemView) {
+        protected open var songMenuRes = SongMenuHelper.MENU_RES
+        protected open val song: Song
+            get() = dataSet[layoutPosition]
+
+        init {
+            menu?.setOnClickListener(object : SongMenuHelper.OnClickSongMenu(activity) {
+                override val song: Song
+                    get() = this@ViewHolder.song
+
+                override val menuRes: Int
+                    get() = songMenuRes
+
+                override fun onMenuItemClick(item: MenuItem): Boolean {
+                    return onSongMenuItemClick(item) || super.onMenuItemClick(item)
+                }
+            })
+        }
+
+        protected open fun onSongMenuItemClick(item: MenuItem): Boolean {
+            if (image != null && image!!.isVisible) {
+                when (item.itemId) {
+                    R.id.action_go_to_album -> {
+                        activity.findNavController(R.id.fragment_container)
+                            .navigate(
+                                R.id.albumDetailsFragment,
+                                bundleOf(EXTRA_ALBUM_ID to song.albumId)
+                            )
+                        return true
+                    }
+                }
+            }
+            return false
+        }
+
+        override fun onClick(v: View?) {
+            if (isInQuickSelectMode) {
+                toggleChecked(layoutPosition)
+            } else {
+                MusicPlayerRemote.openQueue(dataSet, layoutPosition, true)
+            }
+        }
+
+        override fun onLongClick(v: View?): Boolean {
+            return toggleChecked(layoutPosition)
+        }
+    }
+
+    companion object {
+        val TAG: String = SongAdapter::class.java.simpleName
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appshortcuts/AppShortcutIconGenerator.kt

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appshortcuts
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.Icon
+import android.graphics.drawable.LayerDrawable
+import android.os.Build
+import android.util.TypedValue
+import androidx.annotation.RequiresApi
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.util.PreferenceUtil
+import code.name.monkey.retromusic.util.RetroUtil
+
+@RequiresApi(Build.VERSION_CODES.N_MR1)
+object AppShortcutIconGenerator {
+    fun generateThemedIcon(context: Context, iconId: Int): Icon {
+        return if (PreferenceUtil.isColoredAppShortcuts) {
+            generateUserThemedIcon(context, iconId)
+        } else {
+            generateDefaultThemedIcon(context, iconId)
+        }
+    }
+
+    private fun generateDefaultThemedIcon(context: Context, iconId: Int): Icon {
+        // Return an Icon of iconId with default colors
+        return generateThemedIcon(
+            context,
+            iconId,
+            context.getColor(R.color.app_shortcut_default_foreground),
+            context.getColor(R.color.app_shortcut_default_background)
+        )
+    }
+
+    private fun generateUserThemedIcon(context: Context, iconId: Int): Icon {
+        // Get background color from context's theme
+        val typedColorBackground = TypedValue()
+        context.theme.resolveAttribute(android.R.attr.colorBackground, typedColorBackground, true)
+
+        // Return an Icon of iconId with those colors
+        return generateThemedIcon(
+            context, iconId, ThemeStore.accentColor(context), typedColorBackground.data
+        )
+    }
+
+    private fun generateThemedIcon(
+        context: Context,
+        iconId: Int,
+        foregroundColor: Int,
+        backgroundColor: Int
+    ): Icon {
+        // Get and tint foreground and background drawables
+        val vectorDrawable = RetroUtil.getTintedVectorDrawable(context, iconId, foregroundColor)
+        val backgroundDrawable = RetroUtil.getTintedVectorDrawable(
+            context, R.drawable.ic_app_shortcut_background, backgroundColor
+        )
+
+        // Squash the two drawables together
+        val layerDrawable = LayerDrawable(arrayOf(backgroundDrawable, vectorDrawable))
+
+        // Return as an Icon
+        return Icon.createWithBitmap(drawableToBitmap(layerDrawable))
+    }
+
+    private fun drawableToBitmap(drawable: Drawable): Bitmap {
+        val bitmap = Bitmap.createBitmap(
+            drawable.intrinsicWidth, drawable.intrinsicHeight, Bitmap.Config.ARGB_8888
+        )
+        val canvas = Canvas(bitmap)
+        drawable.setBounds(0, 0, canvas.width, canvas.height)
+        drawable.draw(canvas)
+        return bitmap
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appshortcuts/AppShortcutLauncherActivity.kt

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appshortcuts
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Bundle
+import code.name.monkey.retromusic.appshortcuts.shortcuttype.LastAddedShortcutType
+import code.name.monkey.retromusic.appshortcuts.shortcuttype.ShuffleAllShortcutType
+import code.name.monkey.retromusic.appshortcuts.shortcuttype.TopTracksShortcutType
+import code.name.monkey.retromusic.extensions.extraNotNull
+import code.name.monkey.retromusic.model.Playlist
+import code.name.monkey.retromusic.model.smartplaylist.LastAddedPlaylist
+import code.name.monkey.retromusic.model.smartplaylist.ShuffleAllPlaylist
+import code.name.monkey.retromusic.model.smartplaylist.TopTracksPlaylist
+import code.name.monkey.retromusic.service.MusicService
+import code.name.monkey.retromusic.service.MusicService.*
+
+class AppShortcutLauncherActivity : Activity() {
+
+    public override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        when (extraNotNull(KEY_SHORTCUT_TYPE, SHORTCUT_TYPE_NONE).value) {
+            SHORTCUT_TYPE_SHUFFLE_ALL -> {
+                startServiceWithPlaylist(
+                    SHUFFLE_MODE_SHUFFLE, ShuffleAllPlaylist()
+                )
+                DynamicShortcutManager.reportShortcutUsed(this, ShuffleAllShortcutType.id)
+            }
+            SHORTCUT_TYPE_TOP_TRACKS -> {
+                startServiceWithPlaylist(
+                    SHUFFLE_MODE_NONE, TopTracksPlaylist()
+                )
+                DynamicShortcutManager.reportShortcutUsed(this, TopTracksShortcutType.id)
+            }
+            SHORTCUT_TYPE_LAST_ADDED -> {
+                startServiceWithPlaylist(
+                    SHUFFLE_MODE_NONE, LastAddedPlaylist()
+                )
+                DynamicShortcutManager.reportShortcutUsed(this, LastAddedShortcutType.id)
+            }
+        }
+        finish()
+    }
+
+    private fun startServiceWithPlaylist(shuffleMode: Int, playlist: Playlist) {
+        val intent = Intent(this, MusicService::class.java)
+        intent.action = ACTION_PLAY_PLAYLIST
+
+        val bundle = Bundle()
+        bundle.putParcelable(INTENT_EXTRA_PLAYLIST, playlist)
+        bundle.putInt(INTENT_EXTRA_SHUFFLE_MODE, shuffleMode)
+
+        intent.putExtras(bundle)
+
+        startService(intent)
+    }
+
+    companion object {
+        const val KEY_SHORTCUT_TYPE = "io.github.muntashirakon.Music.appshortcuts.ShortcutType"
+        const val SHORTCUT_TYPE_SHUFFLE_ALL = 0L
+        const val SHORTCUT_TYPE_TOP_TRACKS = 1L
+        const val SHORTCUT_TYPE_LAST_ADDED = 2L
+        const val SHORTCUT_TYPE_NONE = 4L
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appshortcuts/DynamicShortcutManager.kt

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appshortcuts
+
+import android.annotation.TargetApi
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ShortcutInfo
+import android.content.pm.ShortcutManager
+import android.graphics.drawable.Icon
+import android.os.Build
+import code.name.monkey.retromusic.appshortcuts.shortcuttype.LastAddedShortcutType
+import code.name.monkey.retromusic.appshortcuts.shortcuttype.ShuffleAllShortcutType
+import code.name.monkey.retromusic.appshortcuts.shortcuttype.TopTracksShortcutType
+
+@TargetApi(Build.VERSION_CODES.N_MR1)
+class DynamicShortcutManager(private val context: Context) {
+    private val shortcutManager: ShortcutManager =
+        this.context.getSystemService(ShortcutManager::class.java)
+
+    private val defaultShortcuts: List<ShortcutInfo>
+        get() = listOf(
+            ShuffleAllShortcutType(context).shortcutInfo,
+            TopTracksShortcutType(context).shortcutInfo,
+            LastAddedShortcutType(context).shortcutInfo
+        )
+
+    fun initDynamicShortcuts() {
+        // if (shortcutManager.dynamicShortcuts.size == 0) {
+        shortcutManager.dynamicShortcuts = defaultShortcuts
+        // }
+    }
+
+    fun updateDynamicShortcuts() {
+        shortcutManager.updateShortcuts(defaultShortcuts)
+    }
+
+    companion object {
+
+        fun createShortcut(
+            context: Context,
+            id: String,
+            shortLabel: String,
+            longLabel: String,
+            icon: Icon,
+            intent: Intent
+        ): ShortcutInfo {
+            return ShortcutInfo.Builder(context, id)
+                .setShortLabel(shortLabel)
+                .setLongLabel(longLabel)
+                .setIcon(icon)
+                .setIntent(intent)
+                .build()
+        }
+
+        fun reportShortcutUsed(context: Context, shortcutId: String) {
+            context.getSystemService(ShortcutManager::class.java).reportShortcutUsed(shortcutId)
+        }
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appshortcuts/shortcuttype/BaseShortcutType.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appshortcuts.shortcuttype
+
+import android.annotation.TargetApi
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ShortcutInfo
+import android.os.Build
+import android.os.Bundle
+import code.name.monkey.retromusic.appshortcuts.AppShortcutLauncherActivity
+
+@TargetApi(Build.VERSION_CODES.N_MR1)
+abstract class BaseShortcutType(internal var context: Context) {
+
+    internal abstract val shortcutInfo: ShortcutInfo
+
+    /**
+     * Creates an Intent that will launch MainActivtiy and immediately play {@param songs} in either shuffle or normal mode
+     *
+     * @param shortcutType Describes the type of shortcut to create (ShuffleAll, TopTracks, custom playlist, etc.)
+     * @return
+     */
+    internal fun getPlaySongsIntent(shortcutType: Long): Intent {
+        val intent = Intent(context, AppShortcutLauncherActivity::class.java)
+        intent.action = Intent.ACTION_VIEW
+        val b = Bundle()
+        b.putLong(AppShortcutLauncherActivity.KEY_SHORTCUT_TYPE, shortcutType)
+        intent.putExtras(b)
+        return intent
+    }
+
+    companion object {
+        internal const val ID_PREFIX = "io.github.muntashirakon.Music.appshortcuts.id."
+        val id: String
+            get() = ID_PREFIX + "invalid"
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appshortcuts/shortcuttype/LastAddedShortcutType.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appshortcuts.shortcuttype
+
+import android.annotation.TargetApi
+import android.content.Context
+import android.content.pm.ShortcutInfo
+import android.os.Build
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.appshortcuts.AppShortcutIconGenerator
+import code.name.monkey.retromusic.appshortcuts.AppShortcutLauncherActivity
+
+@TargetApi(Build.VERSION_CODES.N_MR1)
+class LastAddedShortcutType(context: Context) : BaseShortcutType(context) {
+
+    override val shortcutInfo: ShortcutInfo
+        get() = ShortcutInfo.Builder(
+            context,
+            id
+        ).setShortLabel(context.getString(R.string.app_shortcut_last_added_short)).setLongLabel(
+            context.getString(R.string.app_shortcut_last_added_long)
+        ).setIcon(
+            AppShortcutIconGenerator.generateThemedIcon(
+                context,
+                R.drawable.ic_app_shortcut_last_added
+            )
+        ).setIntent(getPlaySongsIntent(AppShortcutLauncherActivity.SHORTCUT_TYPE_LAST_ADDED))
+            .build()
+
+    companion object {
+
+        val id: String
+            get() = BaseShortcutType.ID_PREFIX + "last_added"
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appshortcuts/shortcuttype/ShuffleAllShortcutType.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appshortcuts.shortcuttype
+
+import android.annotation.TargetApi
+import android.content.Context
+import android.content.pm.ShortcutInfo
+import android.os.Build
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.appshortcuts.AppShortcutIconGenerator
+import code.name.monkey.retromusic.appshortcuts.AppShortcutLauncherActivity
+
+@TargetApi(Build.VERSION_CODES.N_MR1)
+class ShuffleAllShortcutType(context: Context) : BaseShortcutType(context) {
+
+    override val shortcutInfo: ShortcutInfo
+        get() = ShortcutInfo.Builder(context, id)
+            .setShortLabel(context.getString(R.string.app_shortcut_shuffle_all_short))
+            .setLongLabel(context.getString(R.string.app_shortcut_shuffle_all_long))
+            .setIcon(AppShortcutIconGenerator.generateThemedIcon(context, R.drawable.ic_app_shortcut_shuffle_all))
+            .setIntent(getPlaySongsIntent(AppShortcutLauncherActivity.SHORTCUT_TYPE_SHUFFLE_ALL))
+            .build()
+
+    companion object {
+
+        val id: String
+            get() = ID_PREFIX + "shuffle_all"
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appshortcuts/shortcuttype/TopTracksShortcutType.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appshortcuts.shortcuttype
+
+import android.annotation.TargetApi
+import android.content.Context
+import android.content.pm.ShortcutInfo
+import android.os.Build
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.appshortcuts.AppShortcutIconGenerator
+import code.name.monkey.retromusic.appshortcuts.AppShortcutLauncherActivity
+
+@TargetApi(Build.VERSION_CODES.N_MR1)
+class TopTracksShortcutType(context: Context) : BaseShortcutType(context) {
+
+    override val shortcutInfo: ShortcutInfo
+        get() = ShortcutInfo.Builder(
+            context, id
+        ).setShortLabel(context.getString(R.string.app_shortcut_top_tracks_short)).setLongLabel(
+            context.getString(R.string.app_shortcut_top_tracks_long)
+        ).setIcon(
+            AppShortcutIconGenerator.generateThemedIcon(
+                context, R.drawable.ic_app_shortcut_top_tracks
+            )
+        ).setIntent(getPlaySongsIntent(AppShortcutLauncherActivity.SHORTCUT_TYPE_TOP_TRACKS))
+            .build()
+
+    companion object {
+
+        val id: String
+            get() = BaseShortcutType.ID_PREFIX + "top_tracks"
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appwidgets/AppWidgetBig.kt

@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appwidgets
+
+import android.app.PendingIntent
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.drawable.Drawable
+import android.text.TextUtils
+import android.view.View
+import android.widget.RemoteViews
+import code.name.monkey.appthemehelper.util.MaterialValueHelper
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.MainActivity
+import code.name.monkey.retromusic.appwidgets.base.BaseAppWidget
+import code.name.monkey.retromusic.glide.SongGlideRequest
+import code.name.monkey.retromusic.service.MusicService
+import code.name.monkey.retromusic.service.MusicService.*
+import code.name.monkey.retromusic.util.PreferenceUtil
+import code.name.monkey.retromusic.util.RetroUtil
+import com.bumptech.glide.Glide
+import com.bumptech.glide.request.animation.GlideAnimation
+import com.bumptech.glide.request.target.SimpleTarget
+import com.bumptech.glide.request.target.Target
+
+class AppWidgetBig : BaseAppWidget() {
+    private var target: Target<Bitmap>? = null // for cancellation
+
+    /**
+     * Initialize given widgets to default state, where we launch Music on default click and hide
+     * actions if service not running.
+     */
+    override fun defaultAppWidget(context: Context, appWidgetIds: IntArray) {
+        val appWidgetView = RemoteViews(
+            context.packageName, R.layout.app_widget_big
+        )
+
+        appWidgetView.setViewVisibility(
+            R.id.media_titles,
+            View.INVISIBLE
+        )
+        appWidgetView.setImageViewResource(R.id.image, R.drawable.default_audio_art)
+        appWidgetView.setImageViewBitmap(
+            R.id.button_next, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context,
+                    R.drawable.ic_skip_next,
+                    MaterialValueHelper.getPrimaryTextColor(context, false)
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_prev, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context,
+                    R.drawable.ic_skip_previous,
+                    MaterialValueHelper.getPrimaryTextColor(context, false)
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_toggle_play_pause, BaseAppWidget.Companion.createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context,
+                    R.drawable.ic_play_arrow_white_32dp,
+                    MaterialValueHelper.getPrimaryTextColor(context, false)
+                )!!, 1f
+            )
+        )
+
+        linkButtons(context, appWidgetView)
+        pushUpdate(context, appWidgetIds, appWidgetView)
+    }
+
+    /**
+     * Update all active widget instances by pushing changes
+     */
+    override fun performUpdate(service: MusicService, appWidgetIds: IntArray?) {
+        val appWidgetView = RemoteViews(
+            service.packageName, R.layout.app_widget_big
+        )
+
+        val isPlaying = service.isPlaying
+        val song = service.currentSong
+
+        // Set the titles and artwork
+        if (TextUtils.isEmpty(song.title) && TextUtils.isEmpty(song.artistName)) {
+            appWidgetView.setViewVisibility(
+                R.id.media_titles,
+                View.INVISIBLE
+            )
+        } else {
+            appWidgetView.setViewVisibility(
+                R.id.media_titles,
+                View.VISIBLE
+            )
+            appWidgetView.setTextViewText(R.id.title, song.title)
+            appWidgetView.setTextViewText(
+                R.id.text,
+                getSongArtistAndAlbum(song)
+            )
+        }
+
+        val primaryColor = MaterialValueHelper.getPrimaryTextColor(service, false)
+        // Set correct drawable for pause state
+        val playPauseRes =
+            if (isPlaying) R.drawable.ic_pause else R.drawable.ic_play_arrow_white_32dp
+        appWidgetView.setImageViewBitmap(
+            R.id.button_toggle_play_pause, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    service,
+                    playPauseRes,
+                    primaryColor
+                )!!, 1f
+            )
+        )
+
+        // Set prev/next button drawables
+        appWidgetView.setImageViewBitmap(
+            R.id.button_next, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    service,
+                    R.drawable.ic_skip_next,
+                    primaryColor
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_prev, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    service,
+                    R.drawable.ic_skip_previous,
+                    primaryColor
+                )!!, 1f
+            )
+        )
+
+        // Link actions buttons to intents
+        linkButtons(service, appWidgetView)
+
+        // Load the album cover async and push the update on completion
+        val p = RetroUtil.getScreenSize(service)
+        val widgetImageSize = Math.min(p.x, p.y)
+        val appContext = service.applicationContext
+        service.runOnUiThread {
+            if (target != null) {
+                Glide.clear(target)
+            }
+            target = SongGlideRequest.Builder.from(Glide.with(appContext), song)
+                .checkIgnoreMediaStore(appContext).asBitmap().build()
+                .into(object : SimpleTarget<Bitmap>(widgetImageSize, widgetImageSize) {
+                    override fun onResourceReady(
+                        resource: Bitmap,
+                        glideAnimation: GlideAnimation<in Bitmap>
+                    ) {
+                        update(resource)
+                    }
+
+                    override fun onLoadFailed(e: Exception?, errorDrawable: Drawable?) {
+                        super.onLoadFailed(e, errorDrawable)
+                        update(null)
+                    }
+
+                    private fun update(bitmap: Bitmap?) {
+                        if (bitmap == null) {
+                            appWidgetView.setImageViewResource(
+                                R.id.image,
+                                R.drawable.default_audio_art
+                            )
+                        } else {
+                            appWidgetView.setImageViewBitmap(R.id.image, bitmap)
+                        }
+                        pushUpdate(appContext, appWidgetIds, appWidgetView)
+                    }
+                })
+        }
+    }
+
+    /**
+     * Link up various button actions using [PendingIntent].
+     */
+    private fun linkButtons(context: Context, views: RemoteViews) {
+        val action = Intent(context, MainActivity::class.java)
+            .putExtra(
+                MainActivity.EXPAND_PANEL,
+                PreferenceUtil.isExpandPanel
+            )
+        var pendingIntent: PendingIntent
+
+        val serviceName = ComponentName(context, MusicService::class.java)
+
+        // Home
+        action.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+        pendingIntent = PendingIntent.getActivity(context, 0, action, 0)
+        views.setOnClickPendingIntent(R.id.clickable_area, pendingIntent)
+
+        // Previous track
+        pendingIntent = buildPendingIntent(context, ACTION_REWIND, serviceName)
+        views.setOnClickPendingIntent(R.id.button_prev, pendingIntent)
+
+        // Play and pause
+        pendingIntent = buildPendingIntent(context, ACTION_TOGGLE_PAUSE, serviceName)
+        views.setOnClickPendingIntent(R.id.button_toggle_play_pause, pendingIntent)
+
+        // Next track
+        pendingIntent = buildPendingIntent(context, ACTION_SKIP, serviceName)
+        views.setOnClickPendingIntent(R.id.button_next, pendingIntent)
+    }
+
+    companion object {
+
+        const val NAME: String = "app_widget_big"
+        private var mInstance: AppWidgetBig? = null
+
+        val instance: AppWidgetBig
+            @Synchronized get() {
+                if (mInstance == null) {
+                    mInstance = AppWidgetBig()
+                }
+                return mInstance!!
+            }
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appwidgets/AppWidgetCard.kt

@@ -0,0 +1,265 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appwidgets
+
+import android.app.PendingIntent
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.drawable.Drawable
+import android.text.TextUtils
+import android.view.View
+import android.widget.RemoteViews
+import code.name.monkey.appthemehelper.util.MaterialValueHelper
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.MainActivity
+import code.name.monkey.retromusic.appwidgets.base.BaseAppWidget
+import code.name.monkey.retromusic.glide.SongGlideRequest
+import code.name.monkey.retromusic.glide.palette.BitmapPaletteWrapper
+import code.name.monkey.retromusic.service.MusicService
+import code.name.monkey.retromusic.service.MusicService.*
+import code.name.monkey.retromusic.util.ImageUtil
+import code.name.monkey.retromusic.util.PreferenceUtil
+import code.name.monkey.retromusic.util.RetroUtil
+import com.bumptech.glide.Glide
+import com.bumptech.glide.request.animation.GlideAnimation
+import com.bumptech.glide.request.target.SimpleTarget
+import com.bumptech.glide.request.target.Target
+
+class AppWidgetCard : BaseAppWidget() {
+    private var target: Target<BitmapPaletteWrapper>? = null // for cancellation
+
+    /**
+     * Initialize given widgets to default state, where we launch Music on default click and hide
+     * actions if service not running.
+     */
+    override fun defaultAppWidget(context: Context, appWidgetIds: IntArray) {
+        val appWidgetView = RemoteViews(context.packageName, R.layout.app_widget_card)
+
+        appWidgetView.setViewVisibility(R.id.media_titles, View.INVISIBLE)
+        appWidgetView.setImageViewResource(R.id.image, R.drawable.default_audio_art)
+        val secondaryColor = MaterialValueHelper.getSecondaryTextColor(context, true)
+        appWidgetView.setImageViewBitmap(
+            R.id.button_next, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context,
+                    R.drawable.ic_skip_next,
+                    secondaryColor
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_prev, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context,
+                    R.drawable.ic_skip_previous,
+                    secondaryColor
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_toggle_play_pause, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context,
+                    R.drawable.ic_play_arrow_white_32dp,
+                    secondaryColor
+                )!!, 1f
+            )
+        )
+
+        linkButtons(context, appWidgetView)
+        pushUpdate(context, appWidgetIds, appWidgetView)
+    }
+
+    /**
+     * Update all active widget instances by pushing changes
+     */
+    override fun performUpdate(service: MusicService, appWidgetIds: IntArray?) {
+        val appWidgetView = RemoteViews(service.packageName, R.layout.app_widget_card)
+
+        val isPlaying = service.isPlaying
+        val song = service.currentSong
+
+        // Set the titles and artwork
+        if (TextUtils.isEmpty(song.title) && TextUtils.isEmpty(song.artistName)) {
+            appWidgetView.setViewVisibility(R.id.media_titles, View.INVISIBLE)
+        } else {
+            appWidgetView.setViewVisibility(R.id.media_titles, View.VISIBLE)
+            appWidgetView.setTextViewText(R.id.title, song.title)
+            appWidgetView.setTextViewText(R.id.text, getSongArtistAndAlbum(song))
+        }
+
+        // Set correct drawable for pause state
+        val playPauseRes =
+            if (isPlaying) R.drawable.ic_pause else R.drawable.ic_play_arrow_white_32dp
+        appWidgetView.setImageViewBitmap(
+            R.id.button_toggle_play_pause, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    service,
+                    playPauseRes,
+                    MaterialValueHelper.getSecondaryTextColor(service, true)
+                )!!, 1f
+            )
+        )
+
+        // Set prev/next button drawables
+        appWidgetView.setImageViewBitmap(
+            R.id.button_next, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    service,
+                    R.drawable.ic_skip_next,
+                    MaterialValueHelper.getSecondaryTextColor(service, true)
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_prev, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    service,
+                    R.drawable.ic_skip_previous,
+                    MaterialValueHelper.getSecondaryTextColor(service, true)
+                )!!, 1f
+            )
+        )
+
+        // Link actions buttons to intents
+        linkButtons(service, appWidgetView)
+
+        if (imageSize == 0) {
+            imageSize =
+                service.resources.getDimensionPixelSize(R.dimen.app_widget_card_image_size)
+        }
+        if (cardRadius == 0f) {
+            cardRadius =
+                service.resources.getDimension(R.dimen.app_widget_card_radius)
+        }
+
+        // Load the album cover async and push the update on completion
+        service.runOnUiThread {
+            if (target != null) {
+                Glide.clear(target)
+            }
+            target = SongGlideRequest.Builder.from(Glide.with(service), song)
+                .checkIgnoreMediaStore(service).generatePalette(service).build().centerCrop()
+                .into(object : SimpleTarget<BitmapPaletteWrapper>(imageSize, imageSize) {
+                    override fun onResourceReady(
+                        resource: BitmapPaletteWrapper,
+                        glideAnimation: GlideAnimation<in BitmapPaletteWrapper>
+                    ) {
+                        val palette = resource.palette
+                        update(
+                            resource.bitmap, palette.getVibrantColor(
+                                palette.getMutedColor(
+                                    MaterialValueHelper.getSecondaryTextColor(
+                                        service, true
+                                    )
+                                )
+                            )
+                        )
+                    }
+
+                    override fun onLoadFailed(e: Exception?, errorDrawable: Drawable?) {
+                        super.onLoadFailed(e, errorDrawable)
+                        update(null, MaterialValueHelper.getSecondaryTextColor(service, true))
+                    }
+
+                    private fun update(bitmap: Bitmap?, color: Int) {
+                        // Set correct drawable for pause state
+                        appWidgetView.setImageViewBitmap(
+                            R.id.button_toggle_play_pause, ImageUtil.createBitmap(
+                                ImageUtil.getTintedVectorDrawable(
+                                    service, playPauseRes, color
+                                )
+                            )
+                        )
+
+                        // Set prev/next button drawables
+                        appWidgetView.setImageViewBitmap(
+                            R.id.button_next, ImageUtil.createBitmap(
+                                ImageUtil.getTintedVectorDrawable(
+                                    service, R.drawable.ic_skip_next, color
+                                )
+                            )
+                        )
+                        appWidgetView.setImageViewBitmap(
+                            R.id.button_prev, ImageUtil.createBitmap(
+                                ImageUtil.getTintedVectorDrawable(
+                                    service, R.drawable.ic_skip_previous, color
+                                )
+                            )
+                        )
+
+                        val image = getAlbumArtDrawable(service.resources, bitmap)
+                        val roundedBitmap = createRoundedBitmap(
+                            image, imageSize, imageSize, cardRadius, 0F, cardRadius, 0F
+                        )
+                        appWidgetView.setImageViewBitmap(R.id.image, roundedBitmap)
+
+                        pushUpdate(service, appWidgetIds, appWidgetView)
+                    }
+                })
+        }
+    }
+
+    /**
+     * Link up various button actions using [PendingIntent].
+     */
+    private fun linkButtons(context: Context, views: RemoteViews) {
+        val action = Intent(context, MainActivity::class.java)
+            .putExtra(
+                MainActivity.EXPAND_PANEL,
+                PreferenceUtil.isExpandPanel
+            )
+        var pendingIntent: PendingIntent
+
+        val serviceName = ComponentName(context, MusicService::class.java)
+
+        // Home
+        action.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+        pendingIntent = PendingIntent.getActivity(context, 0, action, 0)
+        views.setOnClickPendingIntent(R.id.image, pendingIntent)
+        views.setOnClickPendingIntent(R.id.media_titles, pendingIntent)
+
+        // Previous track
+        pendingIntent = buildPendingIntent(context, ACTION_REWIND, serviceName)
+        views.setOnClickPendingIntent(R.id.button_prev, pendingIntent)
+
+        // Play and pause
+        pendingIntent = buildPendingIntent(context, ACTION_TOGGLE_PAUSE, serviceName)
+        views.setOnClickPendingIntent(R.id.button_toggle_play_pause, pendingIntent)
+
+        // Next track
+        pendingIntent = buildPendingIntent(context, ACTION_SKIP, serviceName)
+        views.setOnClickPendingIntent(R.id.button_next, pendingIntent)
+    }
+
+    companion object {
+
+        const val NAME = "app_widget_card"
+
+        private var mInstance: AppWidgetCard? = null
+        private var imageSize = 0
+        private var cardRadius = 0f
+
+        val instance: AppWidgetCard
+            @Synchronized get() {
+                if (mInstance == null) {
+                    mInstance = AppWidgetCard()
+                }
+                return mInstance!!
+            }
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appwidgets/AppWidgetClassic.kt

@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appwidgets
+
+import android.app.PendingIntent
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.Color
+import android.graphics.drawable.Drawable
+import android.text.TextUtils
+import android.view.View
+import android.widget.RemoteViews
+import code.name.monkey.appthemehelper.util.MaterialValueHelper
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.MainActivity
+import code.name.monkey.retromusic.appwidgets.base.BaseAppWidget
+import code.name.monkey.retromusic.glide.SongGlideRequest
+import code.name.monkey.retromusic.glide.palette.BitmapPaletteWrapper
+import code.name.monkey.retromusic.service.MusicService
+import code.name.monkey.retromusic.service.MusicService.*
+import code.name.monkey.retromusic.util.ImageUtil
+import code.name.monkey.retromusic.util.PreferenceUtil
+import code.name.monkey.retromusic.util.RetroUtil
+import com.bumptech.glide.Glide
+import com.bumptech.glide.request.animation.GlideAnimation
+import com.bumptech.glide.request.target.SimpleTarget
+import com.bumptech.glide.request.target.Target
+
+class AppWidgetClassic : BaseAppWidget() {
+    private var target: Target<BitmapPaletteWrapper>? = null // for cancellation
+
+    /**
+     * Initialize given widgets to default state, where we launch Music on default click and hide
+     * actions if service not running.
+     */
+    override fun defaultAppWidget(context: Context, appWidgetIds: IntArray) {
+        val appWidgetView = RemoteViews(context.packageName, R.layout.app_widget_classic)
+
+        appWidgetView.setViewVisibility(R.id.media_titles, View.INVISIBLE)
+        appWidgetView.setImageViewResource(R.id.image, R.drawable.default_audio_art)
+        appWidgetView.setImageViewBitmap(
+            R.id.button_next,
+            createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context,
+                    R.drawable.ic_skip_next,
+                    MaterialValueHelper.getSecondaryTextColor(context, true)
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_prev,
+            createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context,
+                    R.drawable.ic_skip_previous,
+                    MaterialValueHelper.getSecondaryTextColor(context, true)
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_toggle_play_pause,
+            createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context,
+                    R.drawable.ic_play_arrow_white_32dp,
+                    MaterialValueHelper.getSecondaryTextColor(context, true)
+                )!!, 1f
+            )
+        )
+
+        linkButtons(context, appWidgetView)
+        pushUpdate(context, appWidgetIds, appWidgetView)
+    }
+
+    /**
+     * Update all active widget instances by pushing changes
+     */
+    override fun performUpdate(service: MusicService, appWidgetIds: IntArray?) {
+        val appWidgetView = RemoteViews(service.packageName, R.layout.app_widget_classic)
+
+        val isPlaying = service.isPlaying
+        val song = service.currentSong
+
+        // Set the titles and artwork
+        if (TextUtils.isEmpty(song.title) && TextUtils.isEmpty(song.artistName)) {
+            appWidgetView.setViewVisibility(R.id.media_titles, View.INVISIBLE)
+        } else {
+            appWidgetView.setViewVisibility(R.id.media_titles, View.VISIBLE)
+            appWidgetView.setTextViewText(R.id.title, song.title)
+            appWidgetView.setTextViewText(R.id.text, getSongArtistAndAlbum(song))
+        }
+
+        // Link actions buttons to intents
+        linkButtons(service, appWidgetView)
+
+        if (imageSize == 0) {
+            imageSize =
+                service.resources.getDimensionPixelSize(R.dimen.app_widget_classic_image_size)
+        }
+        if (cardRadius == 0f) {
+            cardRadius = service.resources.getDimension(R.dimen.app_widget_card_radius)
+        }
+
+        // Load the album cover async and push the update on completion
+        val appContext = service.applicationContext
+        service.runOnUiThread {
+            if (target != null) {
+                Glide.clear(target)
+            }
+            target = SongGlideRequest.Builder.from(Glide.with(service), song)
+                .checkIgnoreMediaStore(service).generatePalette(service).build().centerCrop()
+                .into(object : SimpleTarget<BitmapPaletteWrapper>(imageSize, imageSize) {
+                    override fun onResourceReady(
+                        resource: BitmapPaletteWrapper,
+                        glideAnimation: GlideAnimation<in BitmapPaletteWrapper>
+                    ) {
+                        val palette = resource.palette
+                        update(
+                            resource.bitmap,
+                            palette.getVibrantColor(
+                                palette.getMutedColor(
+                                    MaterialValueHelper.getSecondaryTextColor(
+                                        service,
+                                        true
+                                    )
+                                )
+                            )
+                        )
+                    }
+
+                    override fun onLoadFailed(e: Exception?, errorDrawable: Drawable?) {
+                        super.onLoadFailed(e, errorDrawable)
+                        update(null, Color.WHITE)
+                    }
+
+                    private fun update(bitmap: Bitmap?, color: Int) {
+                        // Set correct drawable for pause state
+                        val playPauseRes =
+                            if (isPlaying) R.drawable.ic_pause else R.drawable.ic_play_arrow
+                        appWidgetView.setImageViewBitmap(
+                            R.id.button_toggle_play_pause,
+                            ImageUtil.createBitmap(
+                                ImageUtil.getTintedVectorDrawable(
+                                    service,
+                                    playPauseRes,
+                                    color
+                                )
+                            )
+                        )
+
+                        // Set prev/next button drawables
+                        appWidgetView.setImageViewBitmap(
+                            R.id.button_next,
+                            ImageUtil.createBitmap(
+                                ImageUtil.getTintedVectorDrawable(
+                                    service,
+                                    R.drawable.ic_skip_next,
+                                    color
+                                )
+                            )
+                        )
+                        appWidgetView.setImageViewBitmap(
+                            R.id.button_prev,
+                            ImageUtil.createBitmap(
+                                ImageUtil.getTintedVectorDrawable(
+                                    service,
+                                    R.drawable.ic_skip_previous,
+                                    color
+                                )
+                            )
+                        )
+
+                        val image = getAlbumArtDrawable(service.resources, bitmap)
+                        val roundedBitmap =
+                            createRoundedBitmap(
+                                image,
+                                imageSize,
+                                imageSize,
+                                cardRadius,
+                                0F,
+                                cardRadius,
+                                0F
+                            )
+                        appWidgetView.setImageViewBitmap(R.id.image, roundedBitmap)
+
+                        pushUpdate(appContext, appWidgetIds, appWidgetView)
+                    }
+                })
+        }
+    }
+
+    /**
+     * Link up various button actions using [PendingIntent].
+     */
+    private fun linkButtons(context: Context, views: RemoteViews) {
+        val action = Intent(context, MainActivity::class.java)
+            .putExtra(
+                MainActivity.EXPAND_PANEL,
+                PreferenceUtil.isExpandPanel
+            )
+        var pendingIntent: PendingIntent
+
+        val serviceName = ComponentName(context, MusicService::class.java)
+
+        // Home
+        action.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+        pendingIntent = PendingIntent.getActivity(context, 0, action, 0)
+        views.setOnClickPendingIntent(R.id.image, pendingIntent)
+        views.setOnClickPendingIntent(R.id.media_titles, pendingIntent)
+
+        // Previous track
+        pendingIntent = buildPendingIntent(context, ACTION_REWIND, serviceName)
+        views.setOnClickPendingIntent(R.id.button_prev, pendingIntent)
+
+        // Play and pause
+        pendingIntent = buildPendingIntent(context, ACTION_TOGGLE_PAUSE, serviceName)
+        views.setOnClickPendingIntent(R.id.button_toggle_play_pause, pendingIntent)
+
+        // Next track
+        pendingIntent = buildPendingIntent(context, ACTION_SKIP, serviceName)
+        views.setOnClickPendingIntent(R.id.button_next, pendingIntent)
+    }
+
+    companion object {
+
+        const val NAME = "app_widget_classic"
+
+        private var mInstance: AppWidgetClassic? = null
+        private var imageSize = 0
+        private var cardRadius = 0f
+
+        val instance: AppWidgetClassic
+            @Synchronized get() {
+                if (mInstance == null) {
+                    mInstance = AppWidgetClassic()
+                }
+                return mInstance!!
+            }
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appwidgets/AppWidgetSmall.kt

@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appwidgets
+
+import android.app.PendingIntent
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.drawable.Drawable
+import android.text.TextUtils
+import android.view.View
+import android.widget.RemoteViews
+import code.name.monkey.appthemehelper.util.MaterialValueHelper
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.MainActivity
+import code.name.monkey.retromusic.appwidgets.base.BaseAppWidget
+import code.name.monkey.retromusic.glide.SongGlideRequest
+import code.name.monkey.retromusic.glide.palette.BitmapPaletteWrapper
+import code.name.monkey.retromusic.service.MusicService
+import code.name.monkey.retromusic.service.MusicService.*
+import code.name.monkey.retromusic.util.PreferenceUtil
+import code.name.monkey.retromusic.util.RetroUtil
+import com.bumptech.glide.Glide
+import com.bumptech.glide.request.animation.GlideAnimation
+import com.bumptech.glide.request.target.SimpleTarget
+import com.bumptech.glide.request.target.Target
+
+class AppWidgetSmall : BaseAppWidget() {
+    private var target: Target<BitmapPaletteWrapper>? = null // for cancellation
+
+    /**
+     * Initialize given widgets to default state, where we launch Music on default click and hide
+     * actions if service not running.
+     */
+    override fun defaultAppWidget(context: Context, appWidgetIds: IntArray) {
+        val appWidgetView = RemoteViews(context.packageName, R.layout.app_widget_small)
+
+        appWidgetView.setViewVisibility(R.id.media_titles, View.INVISIBLE)
+        appWidgetView.setImageViewResource(R.id.image, R.drawable.default_audio_art)
+        appWidgetView.setImageViewBitmap(
+            R.id.button_next,
+            createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context,
+                    R.drawable.ic_skip_next,
+                    MaterialValueHelper.getSecondaryTextColor(context, true)
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_prev,
+            createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context,
+                    R.drawable.ic_skip_previous,
+                    MaterialValueHelper.getSecondaryTextColor(context, true)
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_toggle_play_pause,
+            createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context,
+                    R.drawable.ic_play_arrow_white_32dp,
+                    MaterialValueHelper.getSecondaryTextColor(context, true)
+                )!!, 1f
+            )
+        )
+
+        linkButtons(context, appWidgetView)
+        pushUpdate(context, appWidgetIds, appWidgetView)
+    }
+
+    /**
+     * Update all active widget instances by pushing changes
+     */
+    override fun performUpdate(service: MusicService, appWidgetIds: IntArray?) {
+        val appWidgetView = RemoteViews(service.packageName, R.layout.app_widget_small)
+
+        val isPlaying = service.isPlaying
+        val song = service.currentSong
+
+        // Set the titles and artwork
+        if (TextUtils.isEmpty(song.title) && TextUtils.isEmpty(song.artistName)) {
+            appWidgetView.setViewVisibility(R.id.media_titles, View.INVISIBLE)
+        } else {
+            if (TextUtils.isEmpty(song.title) || TextUtils.isEmpty(song.artistName)) {
+                appWidgetView.setTextViewText(R.id.text_separator, "")
+            } else {
+                appWidgetView.setTextViewText(R.id.text_separator, "•")
+            }
+
+            appWidgetView.setViewVisibility(R.id.media_titles, View.VISIBLE)
+            appWidgetView.setTextViewText(R.id.title, song.title)
+            appWidgetView.setTextViewText(R.id.text, song.artistName)
+        }
+
+        // Link actions buttons to intents
+        linkButtons(service, appWidgetView)
+
+        if (imageSize == 0) {
+            imageSize = service.resources.getDimensionPixelSize(R.dimen.app_widget_small_image_size)
+        }
+        if (cardRadius == 0f) {
+            cardRadius = service.resources.getDimension(R.dimen.app_widget_card_radius)
+        }
+
+        // Load the album cover async and push the update on completion
+        val appContext = service.applicationContext
+        service.runOnUiThread {
+            if (target != null) {
+                Glide.clear(target)
+            }
+            target = SongGlideRequest.Builder.from(Glide.with(service), song)
+                .checkIgnoreMediaStore(service).generatePalette(service).build().centerCrop()
+                .into(object : SimpleTarget<BitmapPaletteWrapper>(imageSize, imageSize) {
+                    override fun onResourceReady(
+                        resource: BitmapPaletteWrapper,
+                        glideAnimation: GlideAnimation<in BitmapPaletteWrapper>
+                    ) {
+                        val palette = resource.palette
+                        update(
+                            resource.bitmap, palette.getVibrantColor(
+                                palette.getMutedColor(
+                                    MaterialValueHelper.getSecondaryTextColor(
+                                        service, true
+                                    )
+                                )
+                            )
+                        )
+                    }
+
+                    override fun onLoadFailed(e: Exception?, errorDrawable: Drawable?) {
+                        super.onLoadFailed(e, errorDrawable)
+                        update(null, MaterialValueHelper.getSecondaryTextColor(service, true))
+                    }
+
+                    private fun update(bitmap: Bitmap?, color: Int) {
+                        // Set correct drawable for pause state
+                        val playPauseRes = if (isPlaying) R.drawable.ic_pause
+                        else R.drawable.ic_play_arrow_white_32dp
+                        appWidgetView.setImageViewBitmap(
+                            R.id.button_toggle_play_pause, createBitmap(
+                                RetroUtil.getTintedVectorDrawable(
+                                    service, playPauseRes, color
+                                )!!, 1f
+                            )
+                        )
+
+                        // Set prev/next button drawables
+                        appWidgetView.setImageViewBitmap(
+                            R.id.button_next, createBitmap(
+                                RetroUtil.getTintedVectorDrawable(
+                                    service, R.drawable.ic_skip_next, color
+                                )!!, 1f
+                            )
+                        )
+                        appWidgetView.setImageViewBitmap(
+                            R.id.button_prev, createBitmap(
+                                RetroUtil.getTintedVectorDrawable(
+                                    service, R.drawable.ic_skip_previous, color
+                                )!!, 1f
+                            )
+                        )
+
+                        val image = getAlbumArtDrawable(service.resources, bitmap)
+                        val roundedBitmap = createRoundedBitmap(
+                            image, imageSize, imageSize, cardRadius, 0f, 0f, 0f
+                        )
+                        appWidgetView.setImageViewBitmap(R.id.image, roundedBitmap)
+
+                        pushUpdate(appContext, appWidgetIds, appWidgetView)
+                    }
+                })
+        }
+    }
+
+    /**
+     * Link up various button actions using [PendingIntent].
+     */
+    private fun linkButtons(context: Context, views: RemoteViews) {
+        val action = Intent(context, MainActivity::class.java)
+            .putExtra(
+                MainActivity.EXPAND_PANEL,
+                PreferenceUtil.isExpandPanel
+            )
+        var pendingIntent: PendingIntent
+
+        val serviceName = ComponentName(context, MusicService::class.java)
+
+        // Home
+        action.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+        pendingIntent = PendingIntent.getActivity(context, 0, action, 0)
+        views.setOnClickPendingIntent(R.id.image, pendingIntent)
+        views.setOnClickPendingIntent(R.id.media_titles, pendingIntent)
+
+        // Previous track
+        pendingIntent = buildPendingIntent(context, ACTION_REWIND, serviceName)
+        views.setOnClickPendingIntent(R.id.button_prev, pendingIntent)
+
+        // Play and pause
+        pendingIntent = buildPendingIntent(context, ACTION_TOGGLE_PAUSE, serviceName)
+        views.setOnClickPendingIntent(R.id.button_toggle_play_pause, pendingIntent)
+
+        // Next track
+        pendingIntent = buildPendingIntent(context, ACTION_SKIP, serviceName)
+        views.setOnClickPendingIntent(R.id.button_next, pendingIntent)
+    }
+
+    companion object {
+
+        const val NAME: String = "app_widget_small"
+
+        private var mInstance: AppWidgetSmall? = null
+        private var imageSize = 0
+        private var cardRadius = 0f
+
+        val instance: AppWidgetSmall
+            @Synchronized get() {
+                if (mInstance == null) {
+                    mInstance = AppWidgetSmall()
+                }
+                return mInstance!!
+            }
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appwidgets/AppWidgetText.kt

@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appwidgets
+
+import android.app.PendingIntent
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.text.TextUtils
+import android.view.View
+import android.widget.RemoteViews
+import androidx.core.content.ContextCompat
+import code.name.monkey.retromusic.App
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.MainActivity
+import code.name.monkey.retromusic.appwidgets.base.BaseAppWidget
+import code.name.monkey.retromusic.service.MusicService
+import code.name.monkey.retromusic.service.MusicService.*
+import code.name.monkey.retromusic.util.PreferenceUtil
+import code.name.monkey.retromusic.util.RetroUtil
+
+class AppWidgetText : BaseAppWidget() {
+    override fun defaultAppWidget(context: Context, appWidgetIds: IntArray) {
+        val appWidgetView = RemoteViews(context.packageName, R.layout.app_widget_text)
+
+        appWidgetView.setImageViewBitmap(
+            R.id.button_next, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context, R.drawable.ic_skip_next, ContextCompat.getColor(
+                        context, R.color.md_white_1000
+                    )
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_prev, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context, R.drawable.ic_skip_previous, ContextCompat.getColor(
+                        context, R.color.md_white_1000
+                    )
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_toggle_play_pause, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    context, R.drawable.ic_play_arrow_white_32dp, ContextCompat.getColor(
+                        context, R.color.md_white_1000
+                    )
+                )!!, 1f
+            )
+        )
+
+        appWidgetView.setTextColor(
+            R.id.title, ContextCompat.getColor(context, R.color.md_white_1000)
+        )
+        appWidgetView.setTextColor(
+            R.id.text, ContextCompat.getColor(context, R.color.md_white_1000)
+        )
+
+        linkButtons(context, appWidgetView)
+        pushUpdate(context, appWidgetIds, appWidgetView)
+    }
+
+    /**
+     * Link up various button actions using [PendingIntent].
+     */
+    private fun linkButtons(context: Context, views: RemoteViews) {
+        val action = Intent(context, MainActivity::class.java)
+            .putExtra(
+                MainActivity.EXPAND_PANEL,
+                PreferenceUtil.isExpandPanel
+            )
+        var pendingIntent: PendingIntent
+
+        val serviceName = ComponentName(context, MusicService::class.java)
+
+        // Home
+        action.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+        pendingIntent = PendingIntent.getActivity(context, 0, action, 0)
+        views.setOnClickPendingIntent(R.id.image, pendingIntent)
+        views.setOnClickPendingIntent(R.id.media_titles, pendingIntent)
+
+        // Previous track
+        pendingIntent = buildPendingIntent(context, ACTION_REWIND, serviceName)
+        views.setOnClickPendingIntent(R.id.button_prev, pendingIntent)
+
+        // Play and pause
+        pendingIntent = buildPendingIntent(context, ACTION_TOGGLE_PAUSE, serviceName)
+        views.setOnClickPendingIntent(R.id.button_toggle_play_pause, pendingIntent)
+
+        // Next track
+        pendingIntent = buildPendingIntent(context, ACTION_SKIP, serviceName)
+        views.setOnClickPendingIntent(R.id.button_next, pendingIntent)
+    }
+
+    override fun performUpdate(service: MusicService, appWidgetIds: IntArray?) {
+        val appWidgetView = RemoteViews(service.packageName, R.layout.app_widget_text)
+
+        val isPlaying = service.isPlaying
+        val song = service.currentSong
+
+        // Set the titles and artwork
+        if (TextUtils.isEmpty(song.title) && TextUtils.isEmpty(song.artistName)) {
+            appWidgetView.setViewVisibility(R.id.media_titles, View.INVISIBLE)
+        } else {
+            appWidgetView.setViewVisibility(R.id.media_titles, View.VISIBLE)
+            appWidgetView.setTextViewText(R.id.title, song.title)
+            appWidgetView.setTextViewText(R.id.text, song.artistName)
+        }
+        // Link actions buttons to intents
+        linkButtons(service, appWidgetView)
+
+        // Set correct drawable for pause state
+        val playPauseRes = if (isPlaying) R.drawable.ic_pause
+        else R.drawable.ic_play_arrow_white_32dp
+        appWidgetView.setImageViewBitmap(
+            R.id.button_toggle_play_pause, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    App.getContext(), playPauseRes, ContextCompat.getColor(
+                        App.getContext(), R.color.md_white_1000
+                    )
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_next, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    App.getContext(),
+                    R.drawable.ic_skip_next,
+                    ContextCompat.getColor(
+                        App.getContext(), R.color.md_white_1000
+                    )
+                )!!, 1f
+            )
+        )
+        appWidgetView.setImageViewBitmap(
+            R.id.button_prev, createBitmap(
+                RetroUtil.getTintedVectorDrawable(
+                    App.getContext(),
+                    R.drawable.ic_skip_previous,
+                    ContextCompat.getColor(
+                        App.getContext(), R.color.md_white_1000
+                    )
+                )!!, 1f
+            )
+        )
+
+        pushUpdate(service.applicationContext, appWidgetIds, appWidgetView)
+    }
+
+    companion object {
+
+        const val NAME: String = "app_widget_text"
+
+        private var mInstance: AppWidgetText? = null
+
+        val instance: AppWidgetText
+            @Synchronized get() {
+                if (mInstance == null) {
+                    mInstance = AppWidgetText()
+                }
+                return mInstance!!
+            }
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appwidgets/BootReceiver.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appwidgets
+
+import android.appwidget.AppWidgetManager
+import android.content.BroadcastReceiver
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import code.name.monkey.retromusic.service.MusicService
+
+class BootReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        val widgetManager = AppWidgetManager.getInstance(context)
+
+        // Start music service if there are any existing widgets
+        if (widgetManager.getAppWidgetIds(
+                ComponentName(
+                    context, AppWidgetBig::class.java
+                )
+            ).isNotEmpty() || widgetManager.getAppWidgetIds(
+                ComponentName(
+                    context, AppWidgetClassic::class.java
+                )
+            ).isNotEmpty() || widgetManager.getAppWidgetIds(
+                ComponentName(
+                    context, AppWidgetSmall::class.java
+                )
+            ).isNotEmpty() || widgetManager.getAppWidgetIds(
+                ComponentName(
+                    context, AppWidgetCard::class.java
+                )
+            ).isNotEmpty()
+        ) {
+            val serviceIntent = Intent(context, MusicService::class.java)
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { // not allowed on Oreo
+                context.startService(serviceIntent)
+            }
+        }
+    }
+}

app/src/main/java/code/name/monkey/retromusic/appwidgets/base/BaseAppWidget.kt

@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.appwidgets.base
+
+import android.app.PendingIntent
+import android.appwidget.AppWidgetManager
+import android.appwidget.AppWidgetProvider
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.res.Resources
+import android.graphics.*
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
+import android.os.Build
+import android.text.TextUtils
+import android.widget.RemoteViews
+import androidx.core.content.ContextCompat
+import code.name.monkey.retromusic.App
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.model.Song
+import code.name.monkey.retromusic.service.MusicService
+import code.name.monkey.retromusic.service.MusicService.*
+
+abstract class BaseAppWidget : AppWidgetProvider() {
+
+    /**
+     * {@inheritDoc}
+     */
+    override fun onUpdate(
+        context: Context,
+        appWidgetManager: AppWidgetManager,
+        appWidgetIds: IntArray
+    ) {
+        defaultAppWidget(context, appWidgetIds)
+        val updateIntent = Intent(APP_WIDGET_UPDATE)
+        updateIntent.putExtra(EXTRA_APP_WIDGET_NAME, NAME)
+        updateIntent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, appWidgetIds)
+        updateIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY)
+        context.sendBroadcast(updateIntent)
+    }
+
+    /**
+     * Handle a change notification coming over from [MusicService]
+     */
+    fun notifyChange(service: MusicService, what: String) {
+        if (hasInstances(service)) {
+            if (META_CHANGED == what || PLAY_STATE_CHANGED == what) {
+                performUpdate(service, null)
+            }
+        }
+    }
+
+    protected fun pushUpdate(
+        context: Context,
+        appWidgetIds: IntArray?,
+        views: RemoteViews
+    ) {
+        val appWidgetManager = AppWidgetManager.getInstance(context)
+        if (appWidgetIds != null) {
+            appWidgetManager.updateAppWidget(appWidgetIds, views)
+        } else {
+            appWidgetManager.updateAppWidget(ComponentName(context, javaClass), views)
+        }
+    }
+
+    /**
+     * Check against [AppWidgetManager] if there are any instances of this widget.
+     */
+    private fun hasInstances(context: Context): Boolean {
+        val appWidgetManager = AppWidgetManager.getInstance(context)
+        val mAppWidgetIds = appWidgetManager.getAppWidgetIds(
+            ComponentName(
+                context, javaClass
+            )
+        )
+        return mAppWidgetIds.isNotEmpty()
+    }
+
+    protected fun buildPendingIntent(
+        context: Context,
+        action: String,
+        serviceName: ComponentName
+    ): PendingIntent {
+        val intent = Intent(action)
+        intent.component = serviceName
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            PendingIntent.getForegroundService(context, 0, intent, 0)
+        } else {
+            PendingIntent.getService(context, 0, intent, 0)
+        }
+    }
+
+    protected abstract fun defaultAppWidget(context: Context, appWidgetIds: IntArray)
+
+    abstract fun performUpdate(service: MusicService, appWidgetIds: IntArray?)
+
+    protected fun getAlbumArtDrawable(resources: Resources, bitmap: Bitmap?): Drawable {
+        return if (bitmap == null) {
+            ContextCompat.getDrawable(App.getContext(), R.drawable.default_audio_art)!!
+        } else {
+            BitmapDrawable(resources, bitmap)
+        }
+    }
+
+    protected fun getSongArtistAndAlbum(song: Song): String {
+        val builder = StringBuilder()
+        builder.append(song.artistName)
+        if (!TextUtils.isEmpty(song.artistName) && !TextUtils.isEmpty(song.albumName)) {
+            builder.append(" • ")
+        }
+        builder.append(song.albumName)
+        return builder.toString()
+    }
+
+    companion object {
+
+        const val NAME: String = "app_widget"
+
+        fun createRoundedBitmap(
+            drawable: Drawable?,
+            width: Int,
+            height: Int,
+            tl: Float,
+            tr: Float,
+            bl: Float,
+            br: Float
+        ): Bitmap? {
+            if (drawable == null) {
+                return null
+            }
+
+            val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+            val c = Canvas(bitmap)
+            drawable.setBounds(0, 0, width, height)
+            drawable.draw(c)
+
+            val rounded = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+
+            val canvas = Canvas(rounded)
+            val paint = Paint()
+            paint.shader = BitmapShader(bitmap, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP)
+            paint.isAntiAlias = true
+            canvas.drawPath(
+                composeRoundedRectPath(
+                    RectF(0f, 0f, width.toFloat(), height.toFloat()), tl, tr, bl, br
+                ), paint
+            )
+
+            return rounded
+        }
+
+        fun createBitmap(drawable: Drawable, sizeMultiplier: Float): Bitmap {
+            val bitmap = Bitmap.createBitmap(
+                (drawable.intrinsicWidth * sizeMultiplier).toInt(),
+                (drawable.intrinsicHeight * sizeMultiplier).toInt(),
+                Bitmap.Config.ARGB_8888
+            )
+            val c = Canvas(bitmap)
+            drawable.setBounds(0, 0, c.width, c.height)
+            drawable.draw(c)
+            return bitmap
+        }
+
+        protected fun composeRoundedRectPath(
+            rect: RectF,
+            tl: Float,
+            tr: Float,
+            bl: Float,
+            br: Float
+        ): Path {
+            val path = Path()
+            path.moveTo(rect.left + tl, rect.top)
+            path.lineTo(rect.right - tr, rect.top)
+            path.quadTo(rect.right, rect.top, rect.right, rect.top + tr)
+            path.lineTo(rect.right, rect.bottom - br)
+            path.quadTo(rect.right, rect.bottom, rect.right - br, rect.bottom)
+            path.lineTo(rect.left + bl, rect.bottom)
+            path.quadTo(rect.left, rect.bottom, rect.left, rect.bottom - bl)
+            path.lineTo(rect.left, rect.top + tl)
+            path.quadTo(rect.left, rect.top, rect.left + tl, rect.top)
+            path.close()
+
+            return path
+        }
+    }
+}

app/src/main/java/code/name/monkey/retromusic/db/BlackListStoreDao.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import androidx.room.*
+
+@Dao
+interface BlackListStoreDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun insertBlacklistPath(blackListStoreEntity: BlackListStoreEntity)
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertBlacklistPath(blackListStoreEntities: List<BlackListStoreEntity>)
+
+    @Delete
+    suspend fun deleteBlacklistPath(blackListStoreEntity: BlackListStoreEntity)
+
+    @Query("DELETE FROM BlackListStoreEntity")
+    suspend fun clearBlacklist()
+
+    @Query("SELECT * FROM BlackListStoreEntity")
+    fun blackListPaths(): List<BlackListStoreEntity>
+}

app/src/main/java/code/name/monkey/retromusic/db/BlackListStoreEntity.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+@Entity
+class BlackListStoreEntity(
+    @PrimaryKey
+    val path: String
+)

app/src/main/java/code/name/monkey/retromusic/db/HistoryDao.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import androidx.lifecycle.LiveData
+import androidx.room.*
+
+@Dao
+interface HistoryDao {
+    companion object {
+        private const val HISTORY_LIMIT = 100
+    }
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertSongInHistory(historyEntity: HistoryEntity)
+
+    @Query("SELECT * FROM HistoryEntity WHERE id = :songId LIMIT 1")
+    suspend fun isSongPresentInHistory(songId: Long): HistoryEntity?
+
+    @Update
+    suspend fun updateHistorySong(historyEntity: HistoryEntity)
+
+    @Query("SELECT * FROM HistoryEntity ORDER BY time_played DESC LIMIT $HISTORY_LIMIT")
+    fun historySongs(): List<HistoryEntity>
+
+    @Query("SELECT * FROM HistoryEntity ORDER BY time_played DESC LIMIT $HISTORY_LIMIT")
+    fun observableHistorySongs(): LiveData<List<HistoryEntity>>
+}

app/src/main/java/code/name/monkey/retromusic/db/HistoryEntity.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+@Entity
+class HistoryEntity(
+    @PrimaryKey
+    val id: Long,
+    val title: String,
+    @ColumnInfo(name = "track_number")
+    val trackNumber: Int,
+    val year: Int,
+    val duration: Long,
+    val data: String,
+    @ColumnInfo(name = "date_modified")
+    val dateModified: Long,
+    @ColumnInfo(name = "album_id")
+    val albumId: Long,
+    @ColumnInfo(name = "album_name")
+    val albumName: String,
+    @ColumnInfo(name = "artist_id")
+    val artistId: Long,
+    @ColumnInfo(name = "artist_name")
+    val artistName: String,
+    val composer: String?,
+    @ColumnInfo(name = "album_artist")
+    val albumArtist: String?,
+    @ColumnInfo(name = "time_played")
+    val timePlayed: Long
+)

app/src/main/java/code/name/monkey/retromusic/db/LyricsDao.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import androidx.room.*
+
+@Dao
+interface LyricsDao {
+    @Query("SELECT * FROM LyricsEntity WHERE songId =:songId LIMIT 1")
+    fun lyricsWithSongId(songId: Int): LyricsEntity?
+
+    @Insert
+    fun insertLyrics(lyricsEntity: LyricsEntity)
+
+    @Delete
+    fun deleteLyrics(lyricsEntity: LyricsEntity)
+
+    @Update
+    fun updateLyrics(lyricsEntity: LyricsEntity)
+}

app/src/main/java/code/name/monkey/retromusic/db/LyricsEntity.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+@Entity
+class LyricsEntity(
+    @PrimaryKey val songId: Int,
+    val lyrics: String
+)

app/src/main/java/code/name/monkey/retromusic/db/PlayCountDao.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import androidx.room.*
+
+@Dao
+interface PlayCountDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun insertSongInPlayCount(playCountEntity: PlayCountEntity)
+
+    @Update
+    fun updateSongInPlayCount(playCountEntity: PlayCountEntity)
+
+    @Delete
+    fun deleteSongInPlayCount(playCountEntity: PlayCountEntity)
+
+    @Query("SELECT * FROM PlayCountEntity WHERE id =:songId")
+    fun checkSongExistInPlayCount(songId: Long): List<PlayCountEntity>
+
+    @Query("SELECT * FROM PlayCountEntity ORDER BY play_count DESC")
+    fun playCountSongs(): List<PlayCountEntity>
+
+    @Query("DELETE FROM SongEntity WHERE id =:songId")
+    fun deleteSong(songId: Long)
+
+    @Query("UPDATE PlayCountEntity SET play_count = play_count + 1 WHERE id = :id")
+    fun updateQuantity(id: Long)
+}

app/src/main/java/code/name/monkey/retromusic/db/PlayCountEntity.kt

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+@Entity
+class PlayCountEntity(
+    @PrimaryKey
+    val id: Long,
+    val title: String,
+    @ColumnInfo(name = "track_number")
+    val trackNumber: Int,
+    val year: Int,
+    val duration: Long,
+    val data: String,
+    @ColumnInfo(name = "date_modified")
+    val dateModified: Long,
+    @ColumnInfo(name = "album_id")
+    val albumId: Long,
+    @ColumnInfo(name = "album_name")
+    val albumName: String,
+    @ColumnInfo(name = "artist_id")
+    val artistId: Long,
+    @ColumnInfo(name = "artist_name")
+    val artistName: String,
+    val composer: String?,
+    @ColumnInfo(name = "album_artist")
+    val albumArtist: String?,
+    @ColumnInfo(name = "time_played")
+    val timePlayed: Long,
+    @ColumnInfo(name = "play_count")
+    var playCount: Int
+)

app/src/main/java/code/name/monkey/retromusic/db/PlaylistDao.kt

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import androidx.lifecycle.LiveData
+import androidx.room.*
+
+@Dao
+interface PlaylistDao {
+    @Insert
+    suspend fun createPlaylist(playlistEntity: PlaylistEntity): Long
+
+    @Query("UPDATE PlaylistEntity SET playlist_name = :name WHERE playlist_id = :playlistId")
+    suspend fun renamePlaylist(playlistId: Long, name: String)
+
+    @Query("SELECT * FROM PlaylistEntity WHERE playlist_name = :name")
+    fun isPlaylistExists(name: String): List<PlaylistEntity>
+
+    @Query("SELECT * FROM PlaylistEntity")
+    suspend fun playlists(): List<PlaylistEntity>
+
+    @Query("DELETE FROM SongEntity WHERE playlist_creator_id = :playlistId")
+    suspend fun deletePlaylistSongs(playlistId: Long)
+
+    @Query("DELETE FROM SongEntity WHERE playlist_creator_id = :playlistId AND id = :songId")
+    suspend fun deleteSongFromPlaylist(playlistId: Long, songId: Long)
+
+    @Transaction
+    @Query("SELECT * FROM PlaylistEntity")
+    suspend fun playlistsWithSongs(): List<PlaylistWithSongs>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertSongsToPlaylist(songEntities: List<SongEntity>)
+
+    @Query("SELECT * FROM SongEntity WHERE playlist_creator_id = :playlistId AND id = :songId")
+    suspend fun isSongExistsInPlaylist(playlistId: Long, songId: Long): List<SongEntity>
+
+    @Query("SELECT * FROM SongEntity WHERE playlist_creator_id = :playlistId")
+    fun songsFromPlaylist(playlistId: Long): LiveData<List<SongEntity>>
+
+    @Delete
+    suspend fun deletePlaylist(playlistEntity: PlaylistEntity)
+
+    @Delete
+    suspend fun deletePlaylists(playlistEntities: List<PlaylistEntity>)
+
+    @Delete
+    suspend fun deletePlaylistSongs(songs: List<SongEntity>)
+
+    @Query("SELECT * FROM SongEntity WHERE playlist_creator_id= :playlistId")
+    fun favoritesSongsLiveData(playlistId: Long): LiveData<List<SongEntity>>
+
+    @Query("SELECT * FROM SongEntity WHERE playlist_creator_id= :playlistId")
+    fun favoritesSongs(playlistId: Long): List<SongEntity>
+}

app/src/main/java/code/name/monkey/retromusic/db/PlaylistEntity.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import android.os.Parcelable
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import kotlinx.android.parcel.Parcelize
+
+@Entity
+@Parcelize
+class PlaylistEntity(
+    @PrimaryKey(autoGenerate = true)
+    @ColumnInfo(name = "playlist_id")
+    val playListId: Long = 0,
+    @ColumnInfo(name = "playlist_name")
+    val playlistName: String
+) : Parcelable

app/src/main/java/code/name/monkey/retromusic/db/PlaylistWithSongs.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import android.os.Parcelable
+import androidx.room.Embedded
+import androidx.room.Relation
+import kotlinx.android.parcel.Parcelize
+
+@Parcelize
+data class PlaylistWithSongs(
+    @Embedded val playlistEntity: PlaylistEntity,
+    @Relation(
+        parentColumn = "playlist_id",
+        entityColumn = "playlist_creator_id"
+    )
+    val songs: List<SongEntity>
+) : Parcelable

app/src/main/java/code/name/monkey/retromusic/db/RetroDatabase.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import androidx.room.Database
+import androidx.room.RoomDatabase
+
+@Database(
+    entities = [PlaylistEntity::class, SongEntity::class, HistoryEntity::class, PlayCountEntity::class, BlackListStoreEntity::class, LyricsEntity::class],
+    version = 23,
+    exportSchema = false
+)
+abstract class RetroDatabase : RoomDatabase() {
+    abstract fun playlistDao(): PlaylistDao
+    abstract fun blackListStore(): BlackListStoreDao
+    abstract fun playCountDao(): PlayCountDao
+    abstract fun historyDao(): HistoryDao
+    abstract fun lyricsDao(): LyricsDao
+}

app/src/main/java/code/name/monkey/retromusic/db/SongEntity.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import android.os.Parcelable
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import kotlinx.android.parcel.Parcelize
+
+@Parcelize
+@Entity(indices = [Index(value = ["playlist_creator_id", "id"], unique = true)])
+class SongEntity(
+    @PrimaryKey(autoGenerate = true)
+    @ColumnInfo(name = "song_key")
+    val songPrimaryKey: Long = 0L,
+    @ColumnInfo(name = "playlist_creator_id")
+    val playlistCreatorId: Long,
+    val id: Long,
+    val title: String,
+    @ColumnInfo(name = "track_number")
+    val trackNumber: Int,
+    val year: Int,
+    val duration: Long,
+    val data: String,
+    @ColumnInfo(name = "date_modified")
+    val dateModified: Long,
+    @ColumnInfo(name = "album_id")
+    val albumId: Long,
+    @ColumnInfo(name = "album_name")
+    val albumName: String,
+    @ColumnInfo(name = "artist_id")
+    val artistId: Long,
+    @ColumnInfo(name = "artist_name")
+    val artistName: String,
+    val composer: String?,
+    @ColumnInfo(name = "album_artist")
+    val albumArtist: String?
+) : Parcelable

app/src/main/java/code/name/monkey/retromusic/db/SongExtension.kt

@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.db
+
+import code.name.monkey.retromusic.model.Song
+
+fun List<HistoryEntity>.fromHistoryToSongs(): List<Song> {
+    return map {
+        it.toSong()
+    }
+}
+
+fun List<SongEntity>.toSongs(): List<Song> {
+    return map {
+        it.toSong()
+    }
+}
+
+fun List<Song>.toSongs(playlistId: Long): List<SongEntity> {
+    return map {
+        it.toSongEntity(playlistId)
+    }
+}
+
+fun Song.toHistoryEntity(timePlayed: Long): HistoryEntity {
+    return HistoryEntity(
+        id = id,
+        title = title,
+        trackNumber = trackNumber,
+        year = year,
+        duration = duration,
+        data = data,
+        dateModified = dateModified,
+        albumId = albumId,
+        albumName = albumName,
+        artistId = artistId,
+        artistName = artistName,
+        composer = composer,
+        albumArtist = albumArtist,
+        timePlayed = timePlayed
+    )
+}
+
+fun Song.toSongEntity(playListId: Long): SongEntity {
+    return SongEntity(
+        playlistCreatorId = playListId,
+        id = id,
+        title = title,
+        trackNumber = trackNumber,
+        year = year,
+        duration = duration,
+        data = data,
+        dateModified = dateModified,
+        albumId = albumId,
+        albumName = albumName,
+        artistId = artistId,
+        artistName = artistName,
+        composer = composer,
+        albumArtist = albumArtist
+    )
+}
+
+fun SongEntity.toSong(): Song {
+    return Song(
+        id = id,
+        title = title,
+        trackNumber = trackNumber,
+        year = year,
+        duration = duration,
+        data = data,
+        dateModified = dateModified,
+        albumId = albumId,
+        albumName = albumName,
+        artistId = artistId,
+        artistName = artistName,
+        composer = composer,
+        albumArtist = albumArtist
+    )
+}
+
+fun PlayCountEntity.toSong(): Song {
+    return Song(
+        id = id,
+        title = title,
+        trackNumber = trackNumber,
+        year = year,
+        duration = duration,
+        data = data,
+        dateModified = dateModified,
+        albumId = albumId,
+        albumName = albumName,
+        artistId = artistId,
+        artistName = artistName,
+        composer = composer,
+        albumArtist = albumArtist
+    )
+}
+
+fun HistoryEntity.toSong(): Song {
+    return Song(
+        id = id,
+        title = title,
+        trackNumber = trackNumber,
+        year = year,
+        duration = duration,
+        data = data,
+        dateModified = dateModified,
+        albumId = albumId,
+        albumName = albumName,
+        artistId = artistId,
+        artistName = artistName,
+        composer = composer,
+        albumArtist = albumArtist
+    )
+}
+
+fun Song.toPlayCount(): PlayCountEntity {
+    return PlayCountEntity(
+        id = id,
+        title = title,
+        trackNumber = trackNumber,
+        year = year,
+        duration = duration,
+        data = data,
+        dateModified = dateModified,
+        albumId = albumId,
+        albumName = albumName,
+        artistId = artistId,
+        artistName = artistName,
+        composer = composer,
+        albumArtist = albumArtist,
+        timePlayed = System.currentTimeMillis(),
+        playCount = 1
+    )
+}
+
+fun List<Song>.toSongsEntity(playlistEntity: PlaylistEntity): List<SongEntity> {
+    return map {
+        it.toSongEntity(playlistEntity.playListId)
+    }
+}

app/src/main/java/code/name/monkey/retromusic/dialogs/AddToPlaylistDialog.kt

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.dialogs
+
+import android.app.Dialog
+import android.os.Bundle
+import android.widget.ArrayAdapter
+import androidx.core.os.bundleOf
+import androidx.fragment.app.DialogFragment
+import androidx.lifecycle.lifecycleScope
+import code.name.monkey.retromusic.EXTRA_PLAYLISTS
+import code.name.monkey.retromusic.EXTRA_SONG
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.db.PlaylistEntity
+import code.name.monkey.retromusic.db.toSongsEntity
+import code.name.monkey.retromusic.extensions.colorButtons
+import code.name.monkey.retromusic.extensions.extraNotNull
+import code.name.monkey.retromusic.extensions.materialDialog
+import code.name.monkey.retromusic.fragments.LibraryViewModel
+import code.name.monkey.retromusic.fragments.ReloadType.Playlists
+import code.name.monkey.retromusic.model.Song
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import org.koin.androidx.viewmodel.ext.android.sharedViewModel
+
+class AddToPlaylistDialog : DialogFragment() {
+    private val libraryViewModel by sharedViewModel<LibraryViewModel>()
+
+    companion object {
+        fun create(playlistEntities: List<PlaylistEntity>, song: Song): AddToPlaylistDialog {
+            val list: MutableList<Song> = mutableListOf()
+            list.add(song)
+            return create(playlistEntities, list)
+        }
+
+        fun create(playlistEntities: List<PlaylistEntity>, songs: List<Song>): AddToPlaylistDialog {
+            return AddToPlaylistDialog().apply {
+                arguments = bundleOf(
+                    EXTRA_SONG to songs,
+                    EXTRA_PLAYLISTS to playlistEntities
+                )
+            }
+        }
+    }
+
+    private fun playlistAdapter(playlists: List<String>): ArrayAdapter<String> {
+        val adapter = ArrayAdapter<String>(requireContext(), R.layout.item_simple_text, R.id.title)
+        adapter.addAll(playlists)
+        return adapter
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val playlistEntities = extraNotNull<List<PlaylistEntity>>(EXTRA_PLAYLISTS).value
+        val songs = extraNotNull<List<Song>>(EXTRA_SONG).value
+        val playlistNames = mutableListOf<String>()
+        playlistNames.add(requireContext().resources.getString(R.string.action_new_playlist))
+        for (entity: PlaylistEntity in playlistEntities) {
+            playlistNames.add(entity.playlistName)
+        }
+        return materialDialog(R.string.add_playlist_title)
+            .setAdapter(
+                playlistAdapter(playlistNames)
+            ) { dialog, which ->
+                if (which == 0) {
+                    showCreateDialog(songs)
+                } else {
+                    lifecycleScope.launch(Dispatchers.IO) {
+                        val songEntities = songs.toSongsEntity(playlistEntities[which - 1])
+                        libraryViewModel.insertSongs(songEntities)
+                        libraryViewModel.forceReload(Playlists)
+                    }
+                }
+                dialog.dismiss()
+            }
+            .create().colorButtons()
+    }
+
+    private fun showCreateDialog(songs: List<Song>) {
+        CreatePlaylistDialog.create(songs).show(requireActivity().supportFragmentManager, "Dialog")
+    }
+}

app/src/main/java/code/name/monkey/retromusic/dialogs/BlacklistFolderChooserDialog.java

@@ -0,0 +1,155 @@
+package code.name.monkey.retromusic.dialogs;
+
+import android.Manifest;
+import android.app.Dialog;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Environment;
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.core.app.ActivityCompat;
+import androidx.fragment.app.DialogFragment;
+import code.name.monkey.retromusic.R;
+import com.afollestad.materialdialogs.MaterialDialog;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class BlacklistFolderChooserDialog extends DialogFragment
+    implements MaterialDialog.ListCallback {
+
+  String initialPath = Environment.getExternalStorageDirectory().getAbsolutePath();
+  private File parentFolder;
+  private File[] parentContents;
+  private boolean canGoUp = false;
+  private FolderCallback callback;
+
+  public static BlacklistFolderChooserDialog create() {
+    return new BlacklistFolderChooserDialog();
+  }
+
+  private String[] getContentsArray() {
+    if (parentContents == null) {
+      if (canGoUp) {
+        return new String[] {".."};
+      }
+      return new String[] {};
+    }
+    String[] results = new String[parentContents.length + (canGoUp ? 1 : 0)];
+    if (canGoUp) {
+      results[0] = "..";
+    }
+    for (int i = 0; i < parentContents.length; i++) {
+      results[canGoUp ? i + 1 : i] = parentContents[i].getName();
+    }
+    return results;
+  }
+
+  private File[] listFiles() {
+    File[] contents = parentFolder.listFiles();
+    List<File> results = new ArrayList<>();
+    if (contents != null) {
+      for (File fi : contents) {
+        if (fi.isDirectory()) {
+          results.add(fi);
+        }
+      }
+      Collections.sort(results, new FolderSorter());
+      return results.toArray(new File[results.size()]);
+    }
+    return null;
+  }
+
+  @NonNull
+  @Override
+  public Dialog onCreateDialog(Bundle savedInstanceState) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
+        && ActivityCompat.checkSelfPermission(
+                requireActivity(), Manifest.permission.READ_EXTERNAL_STORAGE)
+            != PackageManager.PERMISSION_GRANTED) {
+      return new MaterialDialog.Builder(requireActivity())
+          .title(R.string.md_error_label)
+          .content(R.string.md_storage_perm_error)
+          .positiveText(android.R.string.ok)
+          .build();
+    }
+    if (savedInstanceState == null) {
+      savedInstanceState = new Bundle();
+    }
+    if (!savedInstanceState.containsKey("current_path")) {
+      savedInstanceState.putString("current_path", initialPath);
+    }
+    parentFolder = new File(savedInstanceState.getString("current_path", File.pathSeparator));
+    checkIfCanGoUp();
+    parentContents = listFiles();
+    MaterialDialog.Builder builder =
+        new MaterialDialog.Builder(requireContext())
+            .title(parentFolder.getAbsolutePath())
+            .items((CharSequence[]) getContentsArray())
+            .itemsCallback(this)
+            .autoDismiss(false)
+            .onPositive(
+                (dialog, which) -> {
+                  callback.onFolderSelection(BlacklistFolderChooserDialog.this, parentFolder);
+                  dismiss();
+                })
+            .onNegative((materialDialog, dialogAction) -> dismiss())
+            .positiveText(R.string.add_action)
+            .negativeText(android.R.string.cancel);
+    return builder.build();
+  }
+
+  @Override
+  public void onSelection(MaterialDialog materialDialog, View view, int i, CharSequence s) {
+    if (canGoUp && i == 0) {
+      parentFolder = parentFolder.getParentFile();
+      if (parentFolder.getAbsolutePath().equals("/storage/emulated")) {
+        parentFolder = parentFolder.getParentFile();
+      }
+      checkIfCanGoUp();
+    } else {
+      parentFolder = parentContents[canGoUp ? i - 1 : i];
+      canGoUp = true;
+      if (parentFolder.getAbsolutePath().equals("/storage/emulated")) {
+        parentFolder = Environment.getExternalStorageDirectory();
+      }
+    }
+    reload();
+  }
+
+  private void checkIfCanGoUp() {
+    canGoUp = parentFolder.getParent() != null;
+  }
+
+  private void reload() {
+    parentContents = listFiles();
+    MaterialDialog dialog = (MaterialDialog) getDialog();
+    dialog.setTitle(parentFolder.getAbsolutePath());
+    dialog.setItems((CharSequence[]) getContentsArray());
+  }
+
+  @Override
+  public void onSaveInstanceState(Bundle outState) {
+    super.onSaveInstanceState(outState);
+    outState.putString("current_path", parentFolder.getAbsolutePath());
+  }
+
+  public void setCallback(FolderCallback callback) {
+    this.callback = callback;
+  }
+
+  public interface FolderCallback {
+    void onFolderSelection(@NonNull BlacklistFolderChooserDialog dialog, @NonNull File folder);
+  }
+
+  private static class FolderSorter implements Comparator<File> {
+
+    @Override
+    public int compare(File lhs, File rhs) {
+      return lhs.getName().compareTo(rhs.getName());
+    }
+  }
+}

app/src/main/java/code/name/monkey/retromusic/dialogs/CreatePlaylistDialog.kt

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.dialogs
+
+import android.app.Dialog
+import android.os.Bundle
+import android.text.TextUtils
+import android.view.LayoutInflater
+import androidx.core.os.bundleOf
+import androidx.fragment.app.DialogFragment
+import com.google.android.material.textfield.TextInputEditText
+import com.google.android.material.textfield.TextInputLayout
+import code.name.monkey.retromusic.EXTRA_SONG
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.extensions.colorButtons
+import code.name.monkey.retromusic.extensions.extra
+import code.name.monkey.retromusic.extensions.materialDialog
+import code.name.monkey.retromusic.fragments.LibraryViewModel
+import code.name.monkey.retromusic.model.Song
+import kotlinx.android.synthetic.main.dialog_playlist.view.*
+import org.koin.androidx.viewmodel.ext.android.sharedViewModel
+
+class CreatePlaylistDialog : DialogFragment() {
+    private val libraryViewModel by sharedViewModel<LibraryViewModel>()
+
+    companion object {
+        fun create(song: Song): CreatePlaylistDialog {
+            val list = mutableListOf<Song>()
+            list.add(song)
+            return create(list)
+        }
+
+        fun create(songs: List<Song>): CreatePlaylistDialog {
+            return CreatePlaylistDialog().apply {
+                arguments = bundleOf(EXTRA_SONG to songs)
+            }
+        }
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val view = LayoutInflater.from(requireActivity()).inflate(R.layout.dialog_playlist, null)
+        val songs: List<Song> = extra<List<Song>>(EXTRA_SONG).value ?: emptyList()
+        val playlistView: TextInputEditText = view.actionNewPlaylist
+        val playlistContainer: TextInputLayout = view.actionNewPlaylistContainer
+        return materialDialog(R.string.new_playlist_title)
+            .setView(view)
+            .setPositiveButton(
+                R.string.create_action
+            ) { _, _ ->
+                val playlistName = playlistView.text.toString()
+                if (!TextUtils.isEmpty(playlistName)) {
+                    libraryViewModel.addToPlaylist(playlistName, songs)
+
+                } else {
+                    playlistContainer.error = "Playlist is can't be empty"
+                }
+            }
+            .create()
+            .colorButtons()
+    }
+}

app/src/main/java/code/name/monkey/retromusic/dialogs/DeletePlaylistDialog.kt

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.dialogs
+
+import android.app.Dialog
+import android.os.Bundle
+import androidx.core.os.bundleOf
+import androidx.core.text.HtmlCompat
+import androidx.fragment.app.DialogFragment
+import code.name.monkey.retromusic.EXTRA_PLAYLIST
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.db.PlaylistEntity
+import code.name.monkey.retromusic.extensions.colorButtons
+import code.name.monkey.retromusic.extensions.extraNotNull
+import code.name.monkey.retromusic.extensions.materialDialog
+import code.name.monkey.retromusic.fragments.LibraryViewModel
+import code.name.monkey.retromusic.fragments.ReloadType
+import org.koin.androidx.viewmodel.ext.android.sharedViewModel
+
+class DeletePlaylistDialog : DialogFragment() {
+
+    private val libraryViewModel by sharedViewModel<LibraryViewModel>()
+
+    companion object {
+
+        fun create(playlist: PlaylistEntity): DeletePlaylistDialog {
+            val list = mutableListOf<PlaylistEntity>()
+            list.add(playlist)
+            return create(list)
+        }
+
+        fun create(playlists: List<PlaylistEntity>): DeletePlaylistDialog {
+            return DeletePlaylistDialog().apply {
+                arguments = bundleOf(EXTRA_PLAYLIST to playlists)
+            }
+        }
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val playlists = extraNotNull<List<PlaylistEntity>>(EXTRA_PLAYLIST).value
+        val title: Int
+        val message: CharSequence
+        //noinspection ConstantConditions
+        if (playlists.size > 1) {
+            title = R.string.delete_playlists_title
+            message = HtmlCompat.fromHtml(
+                String.format(getString(R.string.delete_x_playlists), playlists.size),
+                HtmlCompat.FROM_HTML_MODE_LEGACY
+            )
+        } else {
+            title = R.string.delete_playlist_title
+            message = HtmlCompat.fromHtml(
+                String.format(getString(R.string.delete_playlist_x), playlists[0].playlistName),
+                HtmlCompat.FROM_HTML_MODE_LEGACY
+            )
+        }
+
+        return materialDialog(title)
+            .setTitle(title)
+            .setMessage(message)
+            .setNegativeButton(android.R.string.cancel, null)
+            .setPositiveButton(R.string.action_delete) { _, _ ->
+                libraryViewModel.deleteSongsFromPlaylist(playlists)
+                libraryViewModel.deleteRoomPlaylist(playlists)
+                libraryViewModel.forceReload(ReloadType.Playlists)
+            }
+            .create()
+            .colorButtons()
+    }
+}

app/src/main/java/code/name/monkey/retromusic/dialogs/DeleteSongsDialog.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.dialogs
+
+import android.app.Dialog
+import android.os.Bundle
+import androidx.core.os.bundleOf
+import androidx.core.text.HtmlCompat
+import androidx.fragment.app.DialogFragment
+import code.name.monkey.retromusic.EXTRA_SONG
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.extensions.colorButtons
+import code.name.monkey.retromusic.extensions.extraNotNull
+import code.name.monkey.retromusic.extensions.materialDialog
+import code.name.monkey.retromusic.fragments.LibraryViewModel
+import code.name.monkey.retromusic.helper.MusicPlayerRemote
+import code.name.monkey.retromusic.model.Song
+import code.name.monkey.retromusic.util.MusicUtil
+import org.koin.androidx.viewmodel.ext.android.sharedViewModel
+
+class DeleteSongsDialog : DialogFragment() {
+    private val libraryViewModel by sharedViewModel<LibraryViewModel>()
+
+    companion object {
+        fun create(song: Song): DeleteSongsDialog {
+            val list = ArrayList<Song>()
+            list.add(song)
+            return create(list)
+        }
+
+        fun create(songs: List<Song>): DeleteSongsDialog {
+            return DeleteSongsDialog().apply {
+                arguments = bundleOf(
+                    EXTRA_SONG to ArrayList(songs)
+                )
+            }
+        }
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val songs = extraNotNull<List<Song>>(EXTRA_SONG).value
+        val pair = if (songs.size > 1) {
+            Pair(
+                R.string.delete_songs_title,
+                HtmlCompat.fromHtml(
+                    String.format(getString(R.string.delete_x_songs), songs.size),
+                    HtmlCompat.FROM_HTML_MODE_LEGACY
+                )
+            )
+        } else {
+            Pair(
+                R.string.delete_song_title,
+                HtmlCompat.fromHtml(
+                    String.format(getString(R.string.delete_song_x), songs[0].title),
+                    HtmlCompat.FROM_HTML_MODE_LEGACY
+                )
+            )
+        }
+
+        return materialDialog(pair.first)
+            .setMessage(pair.second)
+            .setCancelable(false)
+            .setPositiveButton(R.string.action_delete) { _, _ ->
+                if (songs.isNotEmpty() and (songs.size == 1) and MusicPlayerRemote.isPlaying(songs.first())) {
+                    MusicPlayerRemote.playNextSong()
+                }
+                MusicUtil.deleteTracks(requireActivity(), songs)
+                libraryViewModel.deleteTracks(songs)
+            }
+            .create()
+            .colorButtons()
+    }
+}

app/src/main/java/code/name/monkey/retromusic/dialogs/ImportPlaylistDialog.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.dialogs
+
+import android.app.Dialog
+import android.os.Bundle
+import androidx.fragment.app.DialogFragment
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.extensions.colorButtons
+import code.name.monkey.retromusic.extensions.materialDialog
+import code.name.monkey.retromusic.fragments.LibraryViewModel
+import org.koin.androidx.viewmodel.ext.android.sharedViewModel
+
+class ImportPlaylistDialog : DialogFragment() {
+    private val libraryViewModel by sharedViewModel<LibraryViewModel>()
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        return materialDialog(R.string.import_playlist)
+            .setMessage(R.string.import_playlist_message)
+            .setPositiveButton(R.string.import_label) { _, _ ->
+                libraryViewModel.importPlaylists()
+            }
+            .create()
+            .colorButtons()
+    }
+}

app/src/main/java/code/name/monkey/retromusic/dialogs/RemoveSongFromPlaylistDialog.kt

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.dialogs
+
+import android.app.Dialog
+import android.os.Bundle
+import androidx.core.os.bundleOf
+import androidx.core.text.HtmlCompat
+import androidx.fragment.app.DialogFragment
+import code.name.monkey.retromusic.EXTRA_SONG
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.db.SongEntity
+import code.name.monkey.retromusic.extensions.colorButtons
+import code.name.monkey.retromusic.extensions.extraNotNull
+import code.name.monkey.retromusic.extensions.materialDialog
+import code.name.monkey.retromusic.fragments.LibraryViewModel
+import org.koin.androidx.viewmodel.ext.android.sharedViewModel
+
+class RemoveSongFromPlaylistDialog : DialogFragment() {
+    private val libraryViewModel by sharedViewModel<LibraryViewModel>()
+
+    companion object {
+        fun create(song: SongEntity): RemoveSongFromPlaylistDialog {
+            val list = mutableListOf<SongEntity>()
+            list.add(song)
+            return create(list)
+        }
+
+        fun create(songs: List<SongEntity>): RemoveSongFromPlaylistDialog {
+            return RemoveSongFromPlaylistDialog().apply {
+                arguments = bundleOf(
+                    EXTRA_SONG to songs
+                )
+            }
+        }
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val songs = extraNotNull<List<SongEntity>>(EXTRA_SONG).value
+        val pair = if (songs.size > 1) {
+            Pair(
+                R.string.remove_songs_from_playlist_title,
+                HtmlCompat.fromHtml(
+                    String.format(getString(R.string.remove_x_songs_from_playlist), songs.size),
+                    HtmlCompat.FROM_HTML_MODE_LEGACY
+                )
+            )
+        } else {
+            Pair(
+                R.string.remove_song_from_playlist_title,
+                HtmlCompat.fromHtml(
+                    String.format(
+                        getString(R.string.remove_song_x_from_playlist),
+                        songs[0].title
+                    ),
+                    HtmlCompat.FROM_HTML_MODE_LEGACY
+                )
+            )
+        }
+        return materialDialog(pair.first)
+            .setMessage(pair.second)
+            .setPositiveButton(R.string.remove_action) { _, _ ->
+                libraryViewModel.deleteSongsInPlaylist(songs)
+            }
+            .setNegativeButton(android.R.string.cancel, null)
+            .create()
+            .colorButtons()
+    }
+}

app/src/main/java/code/name/monkey/retromusic/dialogs/RenamePlaylistDialog.kt

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.dialogs
+
+import android.app.Dialog
+import android.os.Bundle
+import android.view.LayoutInflater
+import androidx.core.os.bundleOf
+import androidx.fragment.app.DialogFragment
+import code.name.monkey.retromusic.EXTRA_PLAYLIST_ID
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.db.PlaylistEntity
+import code.name.monkey.retromusic.extensions.accentColor
+import code.name.monkey.retromusic.extensions.colorButtons
+import code.name.monkey.retromusic.extensions.extraNotNull
+import code.name.monkey.retromusic.extensions.materialDialog
+import code.name.monkey.retromusic.fragments.LibraryViewModel
+import code.name.monkey.retromusic.fragments.ReloadType
+import com.google.android.material.textfield.TextInputEditText
+import com.google.android.material.textfield.TextInputLayout
+import org.koin.androidx.viewmodel.ext.android.sharedViewModel
+
+class RenamePlaylistDialog : DialogFragment() {
+
+    private val libraryViewModel by sharedViewModel<LibraryViewModel>()
+
+    companion object {
+        fun create(playlistEntity: PlaylistEntity): RenamePlaylistDialog {
+            return RenamePlaylistDialog().apply {
+                arguments = bundleOf(
+                    EXTRA_PLAYLIST_ID to playlistEntity
+                )
+            }
+        }
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val playlistEntity = extraNotNull<PlaylistEntity>(EXTRA_PLAYLIST_ID).value
+        val layout = LayoutInflater.from(requireContext()).inflate(R.layout.dialog_playlist, null)
+        val inputEditText: TextInputEditText = layout.findViewById(R.id.actionNewPlaylist)
+        val nameContainer: TextInputLayout = layout.findViewById(R.id.actionNewPlaylistContainer)
+        nameContainer.accentColor()
+        inputEditText.setText(playlistEntity.playlistName)
+        return materialDialog(R.string.rename_playlist_title)
+            .setView(layout)
+            .setNegativeButton(android.R.string.cancel, null)
+            .setPositiveButton(R.string.action_rename) { _, _ ->
+                val name = inputEditText.text.toString()
+                if (name.isNotEmpty()) {
+                    libraryViewModel.renameRoomPlaylist(playlistEntity.playListId, name)
+                    libraryViewModel.forceReload(ReloadType.Playlists)
+                } else {
+                    nameContainer.error = "Playlist name should'nt be empty"
+                }
+            }
+            .create()
+            .colorButtons()
+    }
+}

app/src/main/java/code/name/monkey/retromusic/dialogs/SavePlaylistDialog.kt

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.dialogs
+
+import android.app.Dialog
+import android.media.MediaScannerConnection
+import android.os.Bundle
+import android.widget.Toast
+import androidx.core.os.bundleOf
+import androidx.fragment.app.DialogFragment
+import androidx.lifecycle.lifecycleScope
+import code.name.monkey.retromusic.App
+import code.name.monkey.retromusic.EXTRA_PLAYLIST
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.db.PlaylistWithSongs
+import code.name.monkey.retromusic.extensions.colorButtons
+import code.name.monkey.retromusic.extensions.extraNotNull
+import code.name.monkey.retromusic.extensions.materialDialog
+import code.name.monkey.retromusic.util.PlaylistsUtil
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+class SavePlaylistDialog : DialogFragment() {
+    companion object {
+        fun create(playlistWithSongs: PlaylistWithSongs): SavePlaylistDialog {
+            return SavePlaylistDialog().apply {
+                arguments = bundleOf(
+                    EXTRA_PLAYLIST to playlistWithSongs
+                )
+            }
+        }
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        lifecycleScope.launch(Dispatchers.IO) {
+            val playlistWithSongs = extraNotNull<PlaylistWithSongs>(EXTRA_PLAYLIST).value
+            val file = PlaylistsUtil.savePlaylistWithSongs(playlistWithSongs)
+            MediaScannerConnection.scanFile(
+                requireActivity(),
+                arrayOf<String>(file.path),
+                null
+            ) { _, _ ->
+            }
+            withContext(Dispatchers.Main) {
+                Toast.makeText(
+                    requireContext(),
+                    String.format(App.getContext().getString(R.string.saved_playlist_to), file),
+                    Toast.LENGTH_LONG
+                ).show()
+                dismiss()
+            }
+        }
+    }
+
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        return materialDialog(R.string.save_playlist_title)
+            .setView(R.layout.loading)
+            .create().colorButtons()
+    }
+}

app/src/main/java/code/name/monkey/retromusic/dialogs/SleepTimerDialog.kt

@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.dialogs
+
+import android.annotation.SuppressLint
+import android.app.AlarmManager
+import android.app.Dialog
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.os.CountDownTimer
+import android.os.SystemClock
+import android.view.LayoutInflater
+import android.widget.CheckBox
+import android.widget.SeekBar
+import android.widget.TextView
+import android.widget.Toast
+import androidx.fragment.app.DialogFragment
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.extensions.addAccentColor
+import code.name.monkey.retromusic.extensions.colorButtons
+import code.name.monkey.retromusic.extensions.materialDialog
+import code.name.monkey.retromusic.helper.MusicPlayerRemote
+import code.name.monkey.retromusic.service.MusicService
+import code.name.monkey.retromusic.service.MusicService.ACTION_PENDING_QUIT
+import code.name.monkey.retromusic.service.MusicService.ACTION_QUIT
+import code.name.monkey.retromusic.util.PreferenceUtil
+import com.afollestad.materialdialogs.DialogAction
+import com.afollestad.materialdialogs.MaterialDialog
+
+class SleepTimerDialog : DialogFragment() {
+
+    private var seekArcProgress: Int = 0
+    private lateinit var timerUpdater: TimerUpdater
+    private lateinit var dialog: MaterialDialog
+    private lateinit var shouldFinishLastSong: CheckBox
+    private lateinit var seekBar: SeekBar
+    private lateinit var timerDisplay: TextView
+
+    @SuppressLint("InflateParams")
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        timerUpdater = TimerUpdater()
+        val layout =
+            LayoutInflater.from(requireContext()).inflate(R.layout.dialog_sleep_timer, null)
+        shouldFinishLastSong = layout.findViewById(R.id.shouldFinishLastSong)
+        seekBar = layout.findViewById(R.id.seekBar)
+        timerDisplay = layout.findViewById(R.id.timerDisplay)
+
+        val finishMusic = PreferenceUtil.isSleepTimerFinishMusic
+        shouldFinishLastSong.apply {
+            addAccentColor()
+            isChecked = finishMusic
+        }
+        seekBar.apply {
+            addAccentColor()
+            seekArcProgress = PreferenceUtil.lastSleepTimerValue
+            updateTimeDisplayTime()
+            seekBar.progress = seekArcProgress
+        }
+
+        seekBar.setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
+            override fun onProgressChanged(seekBar: SeekBar, i: Int, b: Boolean) {
+                if (i < 1) {
+                    seekBar.progress = 1
+                    return
+                }
+                seekArcProgress = i
+                updateTimeDisplayTime()
+            }
+
+            override fun onStartTrackingTouch(seekBar: SeekBar) {
+            }
+
+            override fun onStopTrackingTouch(seekBar: SeekBar) {
+                PreferenceUtil.lastSleepTimerValue = seekArcProgress
+            }
+        })
+        return materialDialog(R.string.action_sleep_timer)
+            .setView(layout)
+            .setPositiveButton(R.string.action_set) { _, _ ->
+                PreferenceUtil.isSleepTimerFinishMusic = shouldFinishLastSong.isChecked
+                val minutes = seekArcProgress
+                val pi = makeTimerPendingIntent(PendingIntent.FLAG_CANCEL_CURRENT)
+                val nextSleepTimerElapsedTime = SystemClock.elapsedRealtime() + minutes * 60 * 1000
+                PreferenceUtil.nextSleepTimerElapsedRealTime = nextSleepTimerElapsedTime.toInt()
+                val am = requireContext().getSystemService(Context.ALARM_SERVICE) as AlarmManager
+                am.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, nextSleepTimerElapsedTime, pi)
+
+                Toast.makeText(
+                    requireContext(),
+                    requireContext().resources.getString(R.string.sleep_timer_set, minutes),
+                    Toast.LENGTH_SHORT
+                ).show()
+            }
+            .setNegativeButton(android.R.string.cancel) { _, _ ->
+                val previous = makeTimerPendingIntent(PendingIntent.FLAG_NO_CREATE)
+                if (previous != null) {
+                    val am =
+                        requireContext().getSystemService(Context.ALARM_SERVICE) as AlarmManager
+                    am.cancel(previous)
+                    previous.cancel()
+                    Toast.makeText(
+                        requireContext(),
+                        requireContext().resources.getString(R.string.sleep_timer_canceled),
+                        Toast.LENGTH_SHORT
+                    ).show()
+                    val musicService = MusicPlayerRemote.musicService
+                    if (musicService != null && musicService.pendingQuit) {
+                        musicService.pendingQuit = false
+                        Toast.makeText(
+                            requireContext(),
+                            requireContext().resources.getString(R.string.sleep_timer_canceled),
+                            Toast.LENGTH_SHORT
+                        ).show()
+                    }
+                }
+            }
+            .create()
+            .colorButtons()
+    }
+
+    private fun updateTimeDisplayTime() {
+        timerDisplay.text = "$seekArcProgress min"
+    }
+
+    private fun makeTimerPendingIntent(flag: Int): PendingIntent? {
+        return PendingIntent.getService(requireActivity(), 0, makeTimerIntent(), flag)
+    }
+
+    private fun makeTimerIntent(): Intent {
+        val intent = Intent(requireActivity(), MusicService::class.java)
+        return if (shouldFinishLastSong.isChecked) {
+            intent.setAction(ACTION_PENDING_QUIT)
+        } else intent.setAction(ACTION_QUIT)
+    }
+
+    private fun updateCancelButton() {
+        val musicService = MusicPlayerRemote.musicService
+        if (musicService != null && musicService.pendingQuit) {
+            dialog.getActionButton(DialogAction.NEUTRAL).text =
+                dialog.context.getString(R.string.cancel_current_timer)
+        } else {
+            dialog.getActionButton(DialogAction.NEUTRAL).text = null
+        }
+    }
+
+    private inner class TimerUpdater() :
+        CountDownTimer(
+            PreferenceUtil.nextSleepTimerElapsedRealTime - SystemClock.elapsedRealtime(),
+            1000
+        ) {
+
+        override fun onTick(millisUntilFinished: Long) {
+            seekBar.progress = millisUntilFinished.toInt()
+        }
+
+        override fun onFinish() {
+            updateCancelButton()
+        }
+    }
+}

app/src/main/java/code/name/monkey/retromusic/dialogs/SongDetailDialog.kt

@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.dialogs
+
+import android.annotation.SuppressLint
+import android.app.Dialog
+import android.content.Context
+import android.os.Bundle
+import android.text.Spanned
+import android.util.Log
+import android.view.LayoutInflater
+import android.widget.TextView
+import androidx.annotation.NonNull
+import androidx.core.os.bundleOf
+import androidx.core.text.HtmlCompat
+import androidx.fragment.app.DialogFragment
+import code.name.monkey.retromusic.EXTRA_SONG
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.extensions.colorButtons
+import code.name.monkey.retromusic.extensions.materialDialog
+import code.name.monkey.retromusic.model.Song
+import code.name.monkey.retromusic.util.MusicUtil
+import java.io.File
+import java.io.IOException
+import org.jaudiotagger.audio.AudioFileIO
+import org.jaudiotagger.audio.exceptions.CannotReadException
+import org.jaudiotagger.audio.exceptions.InvalidAudioFrameException
+import org.jaudiotagger.audio.exceptions.ReadOnlyFileException
+import org.jaudiotagger.tag.TagException
+
+class SongDetailDialog : DialogFragment() {
+
+    @SuppressLint("InflateParams")
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val context: Context = requireContext()
+        val dialogView = LayoutInflater.from(context).inflate(R.layout.dialog_file_details, null)
+
+        val song = requireArguments().getParcelable<Song>(EXTRA_SONG)
+        val fileName: TextView = dialogView.findViewById(R.id.fileName)
+        val filePath: TextView = dialogView.findViewById(R.id.filePath)
+        val fileSize: TextView = dialogView.findViewById(R.id.fileSize)
+        val fileFormat: TextView = dialogView.findViewById(R.id.fileFormat)
+        val trackLength: TextView = dialogView.findViewById(R.id.trackLength)
+        val bitRate: TextView = dialogView.findViewById(R.id.bitrate)
+        val samplingRate: TextView = dialogView.findViewById(R.id.samplingRate)
+
+        fileName.text = makeTextWithTitle(context, R.string.label_file_name, "-")
+        filePath.text = makeTextWithTitle(context, R.string.label_file_path, "-")
+        fileSize.text = makeTextWithTitle(context, R.string.label_file_size, "-")
+        fileFormat.text = makeTextWithTitle(context, R.string.label_file_format, "-")
+        trackLength.text = makeTextWithTitle(context, R.string.label_track_length, "-")
+        bitRate.text = makeTextWithTitle(context, R.string.label_bit_rate, "-")
+        samplingRate.text = makeTextWithTitle(context, R.string.label_sampling_rate, "-")
+        if (song != null) {
+            val songFile = File(song.data)
+            if (songFile.exists()) {
+                fileName.text = makeTextWithTitle(context, R.string.label_file_name, songFile.name)
+                filePath.text =
+                    makeTextWithTitle(context, R.string.label_file_path, songFile.absolutePath)
+                fileSize.text =
+                    makeTextWithTitle(
+                        context,
+                        R.string.label_file_size,
+                        getFileSizeString(songFile.length())
+                    )
+                try {
+                    val audioFile = AudioFileIO.read(songFile)
+                    val audioHeader = audioFile.audioHeader
+
+                    fileFormat.text =
+                        makeTextWithTitle(context, R.string.label_file_format, audioHeader.format)
+                    trackLength.text = makeTextWithTitle(
+                        context,
+                        R.string.label_track_length,
+                        MusicUtil.getReadableDurationString((audioHeader.trackLength * 1000).toLong())
+                    )
+                    bitRate.text = makeTextWithTitle(
+                        context,
+                        R.string.label_bit_rate,
+                        audioHeader.bitRate + " kb/s"
+                    )
+                    samplingRate.text =
+                        makeTextWithTitle(
+                            context,
+                            R.string.label_sampling_rate,
+                            audioHeader.sampleRate + " Hz"
+                        )
+                } catch (@NonNull e: CannotReadException) {
+                    Log.e(TAG, "error while reading the song file", e)
+                    // fallback
+                    trackLength.text = makeTextWithTitle(
+                        context,
+                        R.string.label_track_length,
+                        MusicUtil.getReadableDurationString(song.duration)
+                    )
+                } catch (@NonNull e: IOException) {
+                    Log.e(TAG, "error while reading the song file", e)
+                    trackLength.text = makeTextWithTitle(
+                        context,
+                        R.string.label_track_length,
+                        MusicUtil.getReadableDurationString(song.duration)
+                    )
+                } catch (@NonNull e: TagException) {
+                    Log.e(TAG, "error while reading the song file", e)
+                    trackLength.text = makeTextWithTitle(
+                        context,
+                        R.string.label_track_length,
+                        MusicUtil.getReadableDurationString(song.duration)
+                    )
+                } catch (@NonNull e: ReadOnlyFileException) {
+                    Log.e(TAG, "error while reading the song file", e)
+                    trackLength.text = makeTextWithTitle(
+                        context,
+                        R.string.label_track_length,
+                        MusicUtil.getReadableDurationString(song.duration)
+                    )
+                } catch (@NonNull e: InvalidAudioFrameException) {
+                    Log.e(TAG, "error while reading the song file", e)
+                    trackLength.text = makeTextWithTitle(
+                        context,
+                        R.string.label_track_length,
+                        MusicUtil.getReadableDurationString(song.duration)
+                    )
+                }
+            } else {
+                // fallback
+                fileName.text = makeTextWithTitle(context, R.string.label_file_name, song.title)
+                trackLength.text = makeTextWithTitle(
+                    context,
+                    R.string.label_track_length,
+                    MusicUtil.getReadableDurationString(song.duration)
+                )
+            }
+        }
+        return materialDialog(R.string.action_details)
+            .setPositiveButton(android.R.string.ok, null)
+            .setView(dialogView)
+            .create()
+            .colorButtons()
+    }
+
+    companion object {
+
+        val TAG: String = SongDetailDialog::class.java.simpleName
+
+        fun create(song: Song): SongDetailDialog {
+            return SongDetailDialog().apply {
+                arguments = bundleOf(
+                    EXTRA_SONG to song
+                )
+            }
+        }
+
+        private fun makeTextWithTitle(context: Context, titleResId: Int, text: String?): Spanned {
+            return HtmlCompat.fromHtml(
+                "<b>" + context.resources.getString(titleResId) + ": " + "</b>" + text,
+                HtmlCompat.FROM_HTML_MODE_LEGACY
+            )
+        }
+
+        private fun getFileSizeString(sizeInBytes: Long): String {
+            val fileSizeInKB = sizeInBytes / 1024
+            val fileSizeInMB = fileSizeInKB / 1024
+            return "$fileSizeInMB MB"
+        }
+    }
+}

app/src/main/java/code/name/monkey/retromusic/dialogs/SongShareDialog.kt

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.dialogs
+
+import android.app.Dialog
+import android.content.Intent
+import android.os.Bundle
+import androidx.core.os.bundleOf
+import androidx.fragment.app.DialogFragment
+import code.name.monkey.retromusic.EXTRA_SONG
+import code.name.monkey.retromusic.R
+import code.name.monkey.retromusic.activities.ShareInstagramStory
+import code.name.monkey.retromusic.extensions.colorButtons
+import code.name.monkey.retromusic.extensions.materialDialog
+import code.name.monkey.retromusic.model.Song
+import code.name.monkey.retromusic.util.MusicUtil
+
+class SongShareDialog : DialogFragment() {
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val song: Song? = requireArguments().getParcelable(EXTRA_SONG)
+        val listening: String =
+            String.format(
+                getString(R.string.currently_listening_to_x_by_x),
+                song?.title,
+                song?.artistName
+            )
+        return materialDialog(R.string.what_do_you_want_to_share)
+            .setItems(
+                arrayOf(
+                    getString(R.string.the_audio_file),
+                    "\u201C" + listening + "\u201D",
+                    getString(R.string.social_stories)
+                )
+            ) { _, which ->
+                withAction(which, song, listening)
+            }
+            .create()
+            .colorButtons()
+    }
+
+    private fun withAction(
+        which: Int,
+        song: Song?,
+        currentlyListening: String
+    ) {
+        when (which) {
+            0 -> {
+                startActivity(Intent.createChooser(song?.let {
+                    MusicUtil.createShareSongFileIntent(
+                        it,
+                        requireContext()
+                    )
+                }, null))
+            }
+            1 -> {
+                startActivity(
+                    Intent.createChooser(
+                        Intent()
+                            .setAction(Intent.ACTION_SEND)
+                            .putExtra(Intent.EXTRA_TEXT, currentlyListening)
+                            .setType("text/plain"),
+                        null
+                    )
+                )
+            }
+            2 -> {
+                if (song != null) {
+                    startActivity(
+                        Intent(
+                            requireContext(),
+                            ShareInstagramStory::class.java
+                        ).putExtra(
+                            ShareInstagramStory.EXTRA_SONG,
+                            song
+                        )
+                    )
+                }
+            }
+        }
+    }
+
+    companion object {
+
+        fun create(song: Song): SongShareDialog {
+            return SongShareDialog().apply {
+                arguments = bundleOf(
+                    EXTRA_SONG to song
+                )
+            }
+        }
+    }
+}

app/src/main/java/code/name/monkey/retromusic/extensions/ActivityEx.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.extensions
+
+import android.app.Activity
+import androidx.annotation.DimenRes
+import androidx.appcompat.app.AppCompatActivity
+import code.name.monkey.appthemehelper.util.ToolbarContentTintHelper
+import com.google.android.material.appbar.MaterialToolbar
+
+fun AppCompatActivity.applyToolbar(toolbar: MaterialToolbar) {
+    toolbar.setBackgroundColor(surfaceColor())
+    ToolbarContentTintHelper.colorBackButton(toolbar)
+    setSupportActionBar(toolbar)
+}
+
+inline fun <reified T : Any> Activity.extra(key: String, default: T? = null) = lazy {
+    val value = intent?.extras?.get(key)
+    if (value is T) value else default
+}
+
+inline fun <reified T : Any> Activity.extraNotNull(key: String, default: T? = null) = lazy {
+    val value = intent?.extras?.get(key)
+    requireNotNull(if (value is T) value else default) { key }
+}
+
+fun Activity.dip(@DimenRes id: Int): Int {
+    return resources.getDimensionPixelSize(id)
+}

app/src/main/java/code/name/monkey/retromusic/extensions/ColorExt.kt

@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.extensions
+
+import android.app.Dialog
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.Color
+import android.graphics.drawable.Drawable
+import android.widget.Button
+import android.widget.CheckBox
+import android.widget.SeekBar
+import androidx.annotation.AttrRes
+import androidx.annotation.CheckResult
+import androidx.annotation.ColorInt
+import androidx.annotation.ColorRes
+import androidx.appcompat.widget.AppCompatImageView
+import androidx.appcompat.widget.Toolbar
+import androidx.core.content.ContextCompat
+import androidx.core.graphics.drawable.DrawableCompat
+import androidx.fragment.app.Fragment
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.appthemehelper.util.ATHUtil
+import code.name.monkey.appthemehelper.util.ColorUtil
+import code.name.monkey.appthemehelper.util.MaterialValueHelper
+import com.google.android.material.button.MaterialButton
+import com.google.android.material.floatingactionbutton.ExtendedFloatingActionButton
+import com.google.android.material.floatingactionbutton.FloatingActionButton
+import com.google.android.material.progressindicator.CircularProgressIndicator
+import com.google.android.material.textfield.TextInputLayout
+import code.name.monkey.retromusic.App
+import code.name.monkey.retromusic.R
+
+fun Int.ripAlpha(): Int {
+    return ColorUtil.stripAlpha(this)
+}
+
+fun Dialog.colorControlNormal() = resolveColor(android.R.attr.colorControlNormal)
+
+fun Toolbar.backgroundTintList() {
+    val surfaceColor = ATHUtil.resolveColor(context, R.attr.colorSurface, Color.BLACK)
+    val colorStateList = ColorStateList.valueOf(surfaceColor)
+    backgroundTintList = colorStateList
+}
+
+fun Context.accentColor() = ThemeStore.accentColor(this)
+
+fun Fragment.accentColor() = ThemeStore.accentColor(requireContext())
+
+fun Context.surfaceColor() = resolveColor(R.attr.colorSurface, Color.WHITE)
+
+fun Fragment.surfaceColor() = resolveColor(R.attr.colorSurface, Color.WHITE)
+
+fun Context.textColorSecondary() = resolveColor(android.R.attr.textColorSecondary)
+
+fun Fragment.textColorSecondary() = resolveColor(android.R.attr.textColorSecondary)
+
+fun Context.colorControlNormal() = resolveColor(android.R.attr.colorControlNormal)
+
+fun Fragment.colorControlNormal() = resolveColor(android.R.attr.colorControlNormal)
+
+fun Context.textColorPrimary() = resolveColor(android.R.attr.textColorPrimary)
+
+fun Fragment.textColorPrimary() = resolveColor(android.R.attr.textColorPrimary)
+
+fun Context.resolveColor(@AttrRes attr: Int, fallBackColor: Int = 0) =
+    ATHUtil.resolveColor(this, attr, fallBackColor)
+
+fun Fragment.resolveColor(@AttrRes attr: Int, fallBackColor: Int = 0) =
+    ATHUtil.resolveColor(requireContext(), attr, fallBackColor)
+
+fun Dialog.resolveColor(@AttrRes attr: Int, fallBackColor: Int = 0) =
+    ATHUtil.resolveColor(context, attr, fallBackColor)
+
+fun CheckBox.addAccentColor() {
+    buttonTintList = ColorStateList.valueOf(ThemeStore.accentColor(context))
+}
+
+fun SeekBar.addAccentColor() {
+    val colorState = ColorStateList.valueOf(ThemeStore.accentColor(context))
+    progressTintList = colorState
+    thumbTintList = colorState
+}
+
+fun Button.accentTextColor() = setTextColor(ThemeStore.accentColor(App.getContext()))
+
+fun MaterialButton.accentBackgroundColor() {
+    backgroundTintList = ColorStateList.valueOf(ThemeStore.accentColor(App.getContext()))
+}
+
+fun MaterialButton.accentOutlineColor() {
+    val color = ThemeStore.accentColor(context)
+    val colorStateList = ColorStateList.valueOf(color)
+    iconTint = colorStateList
+    strokeColor = colorStateList
+    setTextColor(colorStateList)
+    rippleColor = colorStateList
+}
+
+fun SeekBar.applyColor(@ColorInt color: Int) {
+    thumbTintList = ColorStateList.valueOf(color)
+    progressTintList = ColorStateList.valueOf(color)
+    progressBackgroundTintList = ColorStateList.valueOf(color)
+}
+
+fun ExtendedFloatingActionButton.accentColor() {
+    val color = ThemeStore.accentColor(context)
+    val textColor = MaterialValueHelper.getPrimaryTextColor(context, ColorUtil.isColorLight(color))
+    val colorStateList = ColorStateList.valueOf(color)
+    val textColorStateList = ColorStateList.valueOf(textColor)
+    backgroundTintList = colorStateList
+    setTextColor(textColorStateList)
+    iconTint = textColorStateList
+}
+
+fun FloatingActionButton.accentColor() {
+    val color = ThemeStore.accentColor(context)
+    val textColor = MaterialValueHelper.getPrimaryTextColor(context, ColorUtil.isColorLight(color))
+    val colorStateList = ColorStateList.valueOf(color)
+    val textColorStateList = ColorStateList.valueOf(textColor)
+    backgroundTintList = colorStateList
+    imageTintList = textColorStateList
+}
+
+fun MaterialButton.applyColor(color: Int) {
+    val backgroundColorStateList = ColorStateList.valueOf(color)
+    val textColorColorStateList = ColorStateList.valueOf(
+        MaterialValueHelper.getPrimaryTextColor(
+            context,
+            ColorUtil.isColorLight(color)
+        )
+    )
+    backgroundTintList = backgroundColorStateList
+    setTextColor(textColorColorStateList)
+    iconTint = textColorColorStateList
+}
+
+fun MaterialButton.accentColor() = applyColor(ThemeStore.accentColor(context))
+
+fun MaterialButton.applyOutlineColor(color: Int) {
+    val textColorColorStateList = ColorStateList.valueOf(color)
+    setTextColor(textColorColorStateList)
+    iconTint = textColorColorStateList
+}
+
+fun TextInputLayout.accentColor() {
+    val accentColor = ThemeStore.accentColor(context)
+    val colorState = ColorStateList.valueOf(accentColor)
+    boxStrokeColor = accentColor
+    defaultHintTextColor = colorState
+    isHintAnimationEnabled = true
+}
+
+fun CircularProgressIndicator.accentColor() {
+    val color = ThemeStore.accentColor(context)
+    setIndicatorColor(color)
+    trackColor = ColorUtil.withAlpha(color, 0.2f)
+}
+
+fun CircularProgressIndicator.applyColor(color: Int) {
+    setIndicatorColor(color)
+    trackColor = ColorUtil.withAlpha(color, 0.2f)
+}
+
+fun AppCompatImageView.accentColor(): Int = ThemeStore.accentColor(context)
+
+@CheckResult
+fun Drawable.tint(@ColorInt color: Int): Drawable {
+    val tintedDrawable = DrawableCompat.wrap(this).mutate()
+    DrawableCompat.setTint(this, color)
+    return tintedDrawable
+}
+
+@CheckResult
+fun Drawable.tint(context: Context, @ColorRes color: Int): Drawable =
+    tint(context.getColorCompat(color))
+
+@ColorInt
+fun Context.getColorCompat(@ColorRes colorRes: Int): Int {
+    return ContextCompat.getColor(this, colorRes)
+}

app/src/main/java/code/name/monkey/retromusic/extensions/CursorExtensions.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.extensions
+
+import android.database.Cursor
+
+// exception is rethrown manually in order to have a readable stacktrace
+
+internal fun Cursor.getInt(columnName: String): Int {
+    try {
+        return this.getInt(this.getColumnIndex(columnName))
+    } catch (ex: Throwable) {
+        throw IllegalStateException("invalid column $columnName", ex)
+    }
+}
+
+internal fun Cursor.getLong(columnName: String): Long {
+    try {
+        return this.getLong(this.getColumnIndex(columnName))
+    } catch (ex: Throwable) {
+        throw IllegalStateException("invalid column $columnName", ex)
+    }
+}
+
+internal fun Cursor.getString(columnName: String): String {
+    try {
+        return this.getString(this.getColumnIndex(columnName))
+    } catch (ex: Throwable) {
+        throw IllegalStateException("invalid column $columnName", ex)
+    }
+}
+
+internal fun Cursor.getStringOrNull(columnName: String): String? {
+    try {
+        return this.getString(this.getColumnIndex(columnName))
+    } catch (ex: Throwable) {
+        throw IllegalStateException("invalid column $columnName", ex)
+    }
+}

app/src/main/java/code/name/monkey/retromusic/extensions/DialogExtension.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2020 Hemanth Savarla.
+ *
+ * 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.extensions
+
+import androidx.appcompat.app.AlertDialog
+import androidx.fragment.app.DialogFragment
+import code.name.monkey.retromusic.R
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+
+fun DialogFragment.materialDialog(title: Int): MaterialAlertDialogBuilder {
+    return MaterialAlertDialogBuilder(
+        requireContext(),
+        R.style.MaterialAlertDialogTheme
+    ).setTitle(title)
+}
+
+fun AlertDialog.colorButtons(): AlertDialog {
+    setOnShowListener {
+        getButton(AlertDialog.BUTTON_POSITIVE).accentTextColor()
+        getButton(AlertDialog.BUTTON_NEGATIVE).accentTextColor()
+        getButton(AlertDialog.BUTTON_NEUTRAL).accentTextColor()
+    }
+    return this
+}