My initial commit

Removed Google play dependencies

app/src/main/java/io/github/muntashirakon/music/activities/AboutActivity.kt

@@ -0,0 +1,145 @@
+package io.github.muntashirakon.music.activities
+
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Bundle
+import android.view.MenuItem
+import android.view.View
+import androidx.core.app.ShareCompat
+import androidx.recyclerview.widget.DefaultItemAnimator
+import androidx.recyclerview.widget.LinearLayoutManager
+import io.github.muntashirakon.music.Constants.APP_INSTAGRAM_LINK
+import io.github.muntashirakon.music.Constants.APP_TELEGRAM_LINK
+import io.github.muntashirakon.music.Constants.APP_TWITTER_LINK
+import io.github.muntashirakon.music.Constants.FAQ_LINK
+import io.github.muntashirakon.music.Constants.GITHUB_PROJECT
+import io.github.muntashirakon.music.Constants.PINTEREST
+import io.github.muntashirakon.music.Constants.RATE_ON_GOOGLE_PLAY
+import io.github.muntashirakon.music.Constants.TELEGRAM_CHANGE_LOG
+import io.github.muntashirakon.music.Constants.TRANSLATE
+import io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.activities.base.AbsBaseActivity
+import io.github.muntashirakon.music.adapter.ContributorAdapter
+import io.github.muntashirakon.music.extensions.applyToolbar
+import io.github.muntashirakon.music.model.Contributor
+import io.github.muntashirakon.music.util.NavigationUtil
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import kotlinx.android.synthetic.main.activity_about.*
+import kotlinx.android.synthetic.main.card_credit.*
+import kotlinx.android.synthetic.main.card_other.*
+import kotlinx.android.synthetic.main.card_retro_info.*
+import kotlinx.android.synthetic.main.card_social.*
+import java.io.IOException
+import java.nio.charset.StandardCharsets
+
+class AboutActivity : AbsBaseActivity(), View.OnClickListener {
+
+    private val contributorsJson: String?
+        get() {
+            val json: String
+            try {
+                val inputStream = assets.open("contributors.json")
+                val size = inputStream.available()
+                val buffer = ByteArray(size)
+                inputStream.read(buffer)
+                inputStream.close()
+                json = String(buffer, StandardCharsets.UTF_8)
+            } catch (ex: IOException) {
+                ex.printStackTrace()
+                return null
+            }
+            return json
+        }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_about)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setLightNavigationBar(true)
+
+        applyToolbar(toolbar)
+        version.setSummary(getAppVersion())
+        setUpView()
+        loadContributors()
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        if (item.itemId == android.R.id.home) {
+            onBackPressed()
+            return true
+        }
+        return super.onOptionsItemSelected(item)
+    }
+
+    private fun openUrl(url: String) {
+        val i = Intent(Intent.ACTION_VIEW)
+        i.data = Uri.parse(url)
+        i.flags = Intent.FLAG_ACTIVITY_NEW_TASK
+        startActivity(i)
+    }
+
+    private fun setUpView() {
+        appGithub.setOnClickListener(this)
+        faqLink.setOnClickListener(this)
+        telegramLink.setOnClickListener(this)
+        appRate.setOnClickListener(this)
+        appTranslation.setOnClickListener(this)
+        appShare.setOnClickListener(this)
+        instagramLink.setOnClickListener(this)
+        twitterLink.setOnClickListener(this)
+        changelog.setOnClickListener(this)
+        openSource.setOnClickListener(this)
+        pinterestLink.setOnClickListener(this)
+        bugReportLink.setOnClickListener(this)
+    }
+
+    override fun onClick(view: View) {
+        when (view.id) {
+            R.id.pinterestLink -> openUrl(PINTEREST)
+            R.id.faqLink -> openUrl(FAQ_LINK)
+            R.id.telegramLink -> openUrl(APP_TELEGRAM_LINK)
+            R.id.appGithub -> openUrl(GITHUB_PROJECT)
+            R.id.appTranslation -> openUrl(TRANSLATE)
+            R.id.appRate -> openUrl(RATE_ON_GOOGLE_PLAY)
+            R.id.appShare -> shareApp()
+            R.id.instagramLink -> openUrl(APP_INSTAGRAM_LINK)
+            R.id.twitterLink -> openUrl(APP_TWITTER_LINK)
+            R.id.changelog -> openUrl(TELEGRAM_CHANGE_LOG)
+            R.id.openSource -> NavigationUtil.goToOpenSource(this)
+            R.id.bugReportLink -> NavigationUtil.bugReport(this)
+        }
+    }
+
+    private fun getAppVersion(): String {
+        return try {
+            val isPro = "Pro"
+            val packageInfo = packageManager.getPackageInfo(packageName, 0)
+            "${packageInfo.versionName} $isPro"
+        } catch (e: PackageManager.NameNotFoundException) {
+            e.printStackTrace()
+            "0.0.0"
+        }
+    }
+
+    private fun shareApp() {
+        ShareCompat.IntentBuilder.from(this).setType("text/plain")
+            .setChooserTitle(R.string.share_app)
+            .setText(String.format(getString(R.string.app_share), packageName)).startChooser()
+    }
+
+    private fun loadContributors() {
+        val type = object : TypeToken<List<Contributor>>() {
+
+        }.type
+        val contributors = Gson().fromJson<List<Contributor>>(contributorsJson, type)
+
+        val contributorAdapter = ContributorAdapter(contributors)
+        recyclerView.layoutManager = LinearLayoutManager(this)
+        recyclerView.itemAnimator = DefaultItemAnimator()
+        recyclerView.adapter = contributorAdapter
+    }
+}

app/src/main/java/io/github/muntashirakon/music/activities/DriveModeActivity.kt

@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 2020 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 io.github.muntashirakon.music.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 io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.activities.base.AbsMusicServiceActivity
+import io.github.muntashirakon.music.fragments.base.AbsPlayerControlsFragment
+import io.github.muntashirakon.music.glide.BlurTransformation
+import io.github.muntashirakon.music.glide.RetroMusicColoredTarget
+import io.github.muntashirakon.music.glide.SongGlideRequest
+import io.github.muntashirakon.music.helper.MusicPlayerRemote
+import io.github.muntashirakon.music.helper.MusicProgressViewUpdateHelper
+import io.github.muntashirakon.music.helper.MusicProgressViewUpdateHelper.Callback
+import io.github.muntashirakon.music.helper.PlayPauseButtonOnClickHandler
+import io.github.muntashirakon.music.misc.SimpleOnSeekbarChangeListener
+import io.github.muntashirakon.music.service.MusicService
+import io.github.muntashirakon.music.util.MusicUtil
+import io.github.muntashirakon.music.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_white_24dp else R.drawable.ic_favorite_border_white_24dp)
+            }
+        }
+    }
+
+    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_white_24dp)
+        } else {
+            playPauseButton.setImageResource(R.drawable.ic_play_arrow_white_24dp)
+        }
+    }
+
+    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_white_24dp)
+                repeatButton.setColorFilter(
+                    lastDisabledPlaybackControlsColor,
+                    PorterDuff.Mode.SRC_IN
+                )
+            }
+            MusicService.REPEAT_MODE_ALL -> {
+                repeatButton.setImageResource(R.drawable.ic_repeat_white_24dp)
+                repeatButton.setColorFilter(lastPlaybackControlsColor, PorterDuff.Mode.SRC_IN)
+            }
+            MusicService.REPEAT_MODE_THIS -> {
+                repeatButton.setImageResource(R.drawable.ic_repeat_one_white_24dp)
+                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(color: 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/io/github/muntashirakon/music/activities/GenreDetailsActivity.kt

@@ -0,0 +1,162 @@
+package io.github.muntashirakon.music.activities
+
+import android.os.Bundle
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import androidx.recyclerview.widget.DefaultItemAnimator
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import code.name.monkey.appthemehelper.util.ATHUtil
+import io.github.muntashirakon.music.App
+import io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.activities.base.AbsSlidingMusicPanelActivity
+import io.github.muntashirakon.music.adapter.song.ShuffleButtonSongAdapter
+import io.github.muntashirakon.music.extensions.applyToolbar
+import io.github.muntashirakon.music.helper.menu.GenreMenuHelper
+import io.github.muntashirakon.music.interfaces.CabHolder
+import io.github.muntashirakon.music.model.Genre
+import io.github.muntashirakon.music.model.Song
+import io.github.muntashirakon.music.mvp.presenter.GenreDetailsPresenter
+import io.github.muntashirakon.music.mvp.presenter.GenreDetailsView
+import io.github.muntashirakon.music.util.DensityUtil
+import io.github.muntashirakon.music.util.RetroColorUtil
+import com.afollestad.materialcab.MaterialCab
+import kotlinx.android.synthetic.main.activity_playlist_detail.*
+import java.util.*
+import javax.inject.Inject
+
+/**
+ * @author Hemanth S (h4h13).
+ */
+
+class GenreDetailsActivity : AbsSlidingMusicPanelActivity(), CabHolder, GenreDetailsView {
+
+    @Inject
+    lateinit var genreDetailsPresenter: GenreDetailsPresenter
+
+    private lateinit var genre: Genre
+    private lateinit var songAdapter: ShuffleButtonSongAdapter
+    private var cab: MaterialCab? = null
+
+    private fun getEmojiByUnicode(unicode: Int): String {
+        return String(Character.toChars(unicode))
+    }
+
+    private fun checkIsEmpty() {
+        checkForPadding()
+        emptyEmoji.text = getEmojiByUnicode(0x1F631)
+        empty?.visibility = if (songAdapter.itemCount == 0) View.VISIBLE else View.GONE
+    }
+
+    private fun checkForPadding() {
+        val height = DensityUtil.dip2px(this, 52f)
+        recyclerView.setPadding(0, 0, 0, (height))
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setTaskDescriptionColorAuto()
+        setLightNavigationBar(true)
+        setBottomBarVisibility(View.GONE)
+        if (intent.extras != null) {
+            genre = intent?.extras?.getParcelable(EXTRA_GENRE_ID)!!
+        } else {
+            finish()
+        }
+
+        setUpToolBar()
+        setupRecyclerView()
+
+        App.musicComponent.inject(this)
+        genreDetailsPresenter.attachView(this)
+    }
+
+    private fun setUpToolBar() {
+        applyToolbar(toolbar)
+        title = genre.name
+    }
+
+    override fun onResume() {
+        super.onResume()
+        genreDetailsPresenter.loadGenreSongs(genre.id)
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        genreDetailsPresenter.detachView()
+    }
+
+    override fun createContentView(): View {
+        return wrapSlidingMusicPanel(R.layout.activity_playlist_detail)
+    }
+
+    override fun showEmptyView() {
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.menu_genre_detail, menu)
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        if (item.itemId == android.R.id.home) {
+            onBackPressed()
+        }
+        return GenreMenuHelper.handleMenuClick(this, genre, item)
+    }
+
+    private fun setupRecyclerView() {
+        songAdapter = ShuffleButtonSongAdapter(this, ArrayList(), R.layout.item_list, this)
+        recyclerView.apply {
+            itemAnimator = DefaultItemAnimator()
+            layoutManager = LinearLayoutManager(this@GenreDetailsActivity)
+            adapter = songAdapter
+        }
+        songAdapter.registerAdapterDataObserver(object : RecyclerView.AdapterDataObserver() {
+            override fun onChanged() {
+                super.onChanged()
+                checkIsEmpty()
+            }
+        })
+    }
+
+    override fun songs(songs: List<Song>) {
+        songAdapter.swapDataSet(songs)
+    }
+
+    override fun openCab(menuRes: Int, callback: MaterialCab.Callback): MaterialCab {
+        if (cab != null && cab!!.isActive) cab?.finish()
+        cab = MaterialCab(this, R.id.cab_stub).setMenu(menuRes)
+            .setCloseDrawableRes(R.drawable.ic_close_white_24dp)
+            .setBackgroundColor(
+                RetroColorUtil.shiftBackgroundColorForLightText(
+                    ATHUtil.resolveColor(
+                        this,
+                        R.attr.colorSurface
+                    )
+                )
+            ).start(callback)
+        return cab!!
+    }
+
+    override fun onBackPressed() {
+        if (cab != null && cab!!.isActive) cab!!.finish()
+        else {
+            recyclerView!!.stopScroll()
+            super.onBackPressed()
+        }
+    }
+
+    override fun onMediaStoreChanged() {
+        super.onMediaStoreChanged()
+        genreDetailsPresenter.loadGenreSongs(genre.id)
+    }
+
+    companion object {
+        const val EXTRA_GENRE_ID = "extra_genre_id"
+    }
+}

app/src/main/java/io/github/muntashirakon/music/activities/LicenseActivity.java

@@ -0,0 +1,99 @@
+/*
+ * 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 io.github.muntashirakon.music.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 org.jetbrains.annotations.Nullable;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+
+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 io.github.muntashirakon.music.R;
+import io.github.muntashirakon.music.activities.base.AbsBaseActivity;
+
+/**
+ * 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/io/github/muntashirakon/music/activities/LockScreenActivity.kt

@@ -0,0 +1,100 @@
+package io.github.muntashirakon.music.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 io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.activities.base.AbsMusicServiceActivity
+import io.github.muntashirakon.music.fragments.player.lockscreen.LockScreenPlayerControlsFragment
+import io.github.muntashirakon.music.glide.RetroMusicColoredTarget
+import io.github.muntashirakon.music.glide.SongGlideRequest
+import io.github.muntashirakon.music.helper.MusicPlayerRemote
+import io.github.muntashirakon.music.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: LockScreenPlayerControlsFragment? = null
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+            setShowWhenLocked(true)
+            setTurnScreenOn(true)
+        } else {
+            this.window.addFlags(
+                WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD or
+                        WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
+                        WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
+            )
+        }
+        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 =
+            supportFragmentManager.findFragmentById(R.id.playback_controls_fragment) as LockScreenPlayerControlsFragment?
+
+        findViewById<View>(R.id.slide).apply {
+            translationY = 100f
+            alpha = 0f
+            ViewCompat.animate(this).translationY(0f).alpha(1f).setDuration(1500).start()
+        }
+    }
+
+    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/io/github/muntashirakon/music/activities/LyricsActivity.kt

@@ -0,0 +1,414 @@
+package io.github.muntashirakon.music.activities
+
+import android.R.attr
+import android.annotation.SuppressLint
+import android.content.res.ColorStateList
+import android.os.AsyncTask
+import android.os.Build
+import android.os.Bundle
+import android.text.TextUtils
+import android.view.*
+import androidx.annotation.StringRes
+import androidx.core.content.ContextCompat
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentManager
+import androidx.fragment.app.FragmentStatePagerAdapter
+import androidx.viewpager.widget.ViewPager
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.appthemehelper.util.ATHUtil.resolveColor
+import code.name.monkey.appthemehelper.util.ColorUtil
+import code.name.monkey.appthemehelper.util.MaterialValueHelper
+import code.name.monkey.appthemehelper.util.TintHelper
+import code.name.monkey.appthemehelper.util.ToolbarContentTintHelper
+import io.github.muntashirakon.music.App
+import io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.activities.base.AbsMusicServiceActivity
+import io.github.muntashirakon.music.extensions.surfaceColor
+import io.github.muntashirakon.music.extensions.textColorSecondary
+import io.github.muntashirakon.music.fragments.base.AbsMusicServiceFragment
+import io.github.muntashirakon.music.helper.MusicPlayerRemote
+import io.github.muntashirakon.music.helper.MusicProgressViewUpdateHelper
+import io.github.muntashirakon.music.lyrics.LrcHelper
+import io.github.muntashirakon.music.model.Song
+import io.github.muntashirakon.music.model.lyrics.Lyrics
+import io.github.muntashirakon.music.util.LyricUtil
+import io.github.muntashirakon.music.util.MusicUtil
+import io.github.muntashirakon.music.util.PreferenceUtil
+import kotlinx.android.synthetic.main.activity_lyrics.*
+import kotlinx.android.synthetic.main.fragment_lyrics.*
+import kotlinx.android.synthetic.main.fragment_synced.*
+import java.io.File
+
+class LyricsActivity : AbsMusicServiceActivity(), View.OnClickListener,
+    ViewPager.OnPageChangeListener {
+    override fun onPageScrollStateChanged(state: Int) {
+        when (state) {
+            ViewPager.SCROLL_STATE_IDLE -> fab.show()
+            ViewPager.SCROLL_STATE_DRAGGING,
+            ViewPager.SCROLL_STATE_SETTLING -> fab.hide()
+        }
+    }
+
+    override fun onPageScrolled(position: Int, positionOffset: Float, positionOffsetPixels: Int) {
+    }
+
+    override fun onPageSelected(position: Int) {
+        PreferenceUtil.lyricsOption = position
+        if (position == 0) fab.text = getString(R.string.synced_lyrics)
+        else if (position == 1) fab.text = getString(R.string.lyrics)
+    }
+
+    override fun onClick(v: View?) {
+        when (viewPager.currentItem) {
+            0 -> showSyncedLyrics()
+            1 -> showLyricsSaveDialog()
+        }
+    }
+
+    private lateinit var song: Song
+    private var lyricsString: String? = null
+
+    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
+        }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_lyrics)
+        setStatusbarColorAuto()
+        setTaskDescriptionColorAuto()
+        setNavigationbarColorAuto()
+
+        fab.backgroundTintList = ColorStateList.valueOf(ThemeStore.accentColor(this))
+        ColorStateList.valueOf(
+            MaterialValueHelper.getPrimaryTextColor(
+                this,
+                ColorUtil.isColorLight(ThemeStore.accentColor(this))
+            )
+        )
+            .apply {
+                fab.setTextColor(this)
+                fab.iconTint = this
+            }
+        setupWakelock()
+
+        viewPager.apply {
+            adapter = PagerAdapter(supportFragmentManager)
+            currentItem = PreferenceUtil.lyricsOption
+            addOnPageChangeListener(this@LyricsActivity)
+        }
+
+
+        toolbar.setBackgroundColor(surfaceColor())
+        tabs.setBackgroundColor(surfaceColor())
+        ToolbarContentTintHelper.colorBackButton(toolbar)
+        setSupportActionBar(toolbar)
+        tabs.setupWithViewPager(viewPager)
+        tabs.setSelectedTabIndicator(
+            TintHelper.createTintedDrawable(
+                ContextCompat.getDrawable(
+                    this,
+                    R.drawable.tab_indicator
+                ), ThemeStore.accentColor(this)
+            )
+        )
+        tabs.setTabTextColors(
+            textColorSecondary(),
+            ThemeStore.accentColor(this)
+        )
+        tabs.setSelectedTabIndicatorColor(ThemeStore.accentColor(this))
+
+        fab.setOnClickListener(this)
+    }
+
+    override fun onPlayingMetaChanged() {
+        super.onPlayingMetaChanged()
+        updateTitleSong()
+    }
+
+    override fun onServiceConnected() {
+        super.onServiceConnected()
+        updateTitleSong()
+    }
+
+    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 onOptionsItemSelected(item: MenuItem): Boolean {
+        if (item.itemId == android.R.id.home) {
+            finish()
+            return true
+        }
+        return super.onOptionsItemSelected(item)
+    }
+
+    private fun showSyncedLyrics() {
+        var content = ""
+        try {
+            content = LyricUtil.getStringFromFile(song.title, song.artistName)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+        /*val materialDialog = MaterialDialog(this)
+            .show {
+                title(R.string.add_time_framed_lryics)
+                negativeButton(R.string.action_search) {
+                    RetroUtil.openUrl(this@LyricsActivity, googleSearchLrcUrl)
+                }
+                input(
+                    hint = getString(R.string.paste_lyrics_here),
+                    prefill = content,
+                    inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_FLAG_MULTI_LINE
+                ) { _, input ->
+                    LyricUtil.writeLrcToLoc(song.title, song.artistName, input.toString())
+                }
+                positiveButton(android.R.string.ok) {
+                    updateSong()
+                }
+            }
+
+        MaterialUtil.setTint(materialDialog.getInputLayout(), false)*/
+    }
+
+    private fun updateSong() {
+        val page =
+            supportFragmentManager.findFragmentByTag("android:switcher:" + R.id.viewPager + ":" + viewPager.currentItem)
+        if (viewPager.currentItem == 0 && page != null) {
+            (page as BaseLyricsFragment).upDateSong()
+        }
+    }
+
+    private fun showLyricsSaveDialog() {
+        val content: String = if (lyricsString == null) {
+            ""
+        } else {
+            lyricsString!!
+        }
+
+        /*val materialDialog = MaterialDialog(
+            this
+        ).show {
+
+            title(R.string.add_lyrics)
+            negativeButton(R.string.action_search) {
+                RetroUtil.openUrl(this@LyricsActivity, getGoogleSearchUrl())
+            }
+            input(
+                hint = getString(R.string.paste_lyrics_here),
+                prefill = content,
+                inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_FLAG_MULTI_LINE
+            ) { _, input ->
+                val fieldKeyValueMap = EnumMap<FieldKey, String>(FieldKey::class.java)
+                fieldKeyValueMap[FieldKey.LYRICS] = input.toString()
+                WriteTagsAsyncTask(this@LyricsActivity).execute(
+                    WriteTagsAsyncTask.LoadingInfo(
+                        getSongPaths(song), fieldKeyValueMap, null
+                    )
+                )
+            }
+            positiveButton(android.R.string.ok) {
+                updateSong()
+            }
+        }
+        MaterialUtil.setTint(materialDialog.getInputLayout(), false)*/
+    }
+
+    private fun getSongPaths(song: Song): ArrayList<String> {
+        val paths = ArrayList<String>(1)
+        paths.add(song.data)
+        return paths
+    }
+
+    private fun getGoogleSearchUrl(): String {
+        var baseUrl = "http://www.google.com/search?"
+        var query = song.title + "+" + song.artistName
+        query = "q=" + query.replace(" ", "+") + " lyrics"
+        baseUrl += query
+        return baseUrl
+    }
+
+    class PagerAdapter(fm: FragmentManager) : FragmentStatePagerAdapter(
+        fm, BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT
+    ) {
+
+        class Tabs(
+            @StringRes val title: Int, val fragment: Fragment
+        )
+
+        private var tabs = ArrayList<Tabs>()
+
+        init {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1) {
+                tabs.add(Tabs(R.string.synced_lyrics, SyncedLyricsFragment()))
+            }
+            tabs.add(Tabs(R.string.normal_lyrics, OfflineLyricsFragment()))
+        }
+
+        override fun getItem(position: Int): Fragment {
+            return tabs[position].fragment
+        }
+
+        override fun getPageTitle(position: Int): CharSequence? {
+            return App.getContext().getString(tabs[position].title)
+        }
+
+        override fun getCount(): Int {
+            return tabs.size
+        }
+    }
+
+    abstract class BaseLyricsFragment : AbsMusicServiceFragment() {
+        abstract fun upDateSong()
+
+        override fun onPlayingMetaChanged() {
+            super.onPlayingMetaChanged()
+            upDateSong()
+        }
+
+        override fun onServiceConnected() {
+            super.onServiceConnected()
+            upDateSong()
+        }
+    }
+
+    class OfflineLyricsFragment : BaseLyricsFragment() {
+        override fun upDateSong() {
+            loadSongLyrics()
+        }
+
+        private var updateLyricsAsyncTask: AsyncTask<*, *, *>? = null
+        private var lyrics: Lyrics? = null
+
+        @SuppressLint("StaticFieldLeak")
+        private fun loadSongLyrics() {
+            if (updateLyricsAsyncTask != null) {
+                updateLyricsAsyncTask!!.cancel(false)
+            }
+            val song = MusicPlayerRemote.currentSong
+            updateLyricsAsyncTask = object : AsyncTask<Void?, Void?, Lyrics?>() {
+                override fun doInBackground(vararg params: Void?): Lyrics? {
+                    val data = MusicUtil.getLyrics(song)
+                    return if (TextUtils.isEmpty(data)) {
+                        null
+                    } else Lyrics.parse(song, data!!)
+                }
+
+                override fun onPreExecute() {
+                    super.onPreExecute()
+                    lyrics = null
+                }
+
+                override fun onPostExecute(l: Lyrics?) {
+                    lyrics = l
+                    offlineLyrics?.visibility = View.VISIBLE
+                    if (l == null) {
+                        offlineLyrics?.setText(R.string.no_lyrics_found)
+                        return
+                    }
+                    (activity as LyricsActivity).lyricsString = l.text
+                    offlineLyrics?.text = l.text
+                }
+
+                override fun onCancelled(s: Lyrics?) {
+                    onPostExecute(null)
+                }
+            }.execute()
+        }
+
+        override fun onActivityCreated(savedInstanceState: Bundle?) {
+            super.onActivityCreated(savedInstanceState)
+            loadSongLyrics()
+        }
+
+        override fun onDestroyView() {
+            super.onDestroyView()
+            if (updateLyricsAsyncTask != null && !updateLyricsAsyncTask!!.isCancelled) {
+                updateLyricsAsyncTask?.cancel(true)
+            }
+        }
+
+        override fun onCreateView(
+            inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
+        ): View? {
+            return inflater.inflate(R.layout.fragment_lyrics, container, false)
+        }
+    }
+
+    class SyncedLyricsFragment : BaseLyricsFragment(), MusicProgressViewUpdateHelper.Callback {
+        override fun upDateSong() {
+            loadLRCLyrics()
+        }
+
+        private lateinit var updateHelper: MusicProgressViewUpdateHelper
+        override fun onCreateView(
+            inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
+        ): View? {
+            return inflater.inflate(R.layout.fragment_synced, container, false)
+        }
+
+        override fun onCreate(savedInstanceState: Bundle?) {
+            super.onCreate(savedInstanceState)
+            updateHelper = MusicProgressViewUpdateHelper(this, 500, 1000)
+        }
+
+        override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+            super.onViewCreated(view, savedInstanceState)
+            setupLyricsView()
+        }
+
+        private fun setupLyricsView() {
+            lyricsView.apply {
+                setCurrentPlayLineColor(ThemeStore.accentColor(requireContext()))
+                setIndicatorTextColor(ThemeStore.accentColor(requireContext()))
+                setCurrentIndicateLineTextColor(
+                    resolveColor(
+                        requireContext(),
+                        attr.textColorPrimary
+                    )
+                )
+                setNoLrcTextColor(resolveColor(requireContext(), attr.textColorPrimary))
+                setOnPlayIndicatorLineListener { time, _ -> MusicPlayerRemote.seekTo(time.toInt()) }
+            }
+        }
+
+        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.resetView("Empty")
+            val song = MusicPlayerRemote.currentSong
+            if (LyricUtil.isLrcFileExist(song.title, song.artistName)) {
+                showLyricsLocal(LyricUtil.getLocalLyricFile(song.title, song.artistName))
+            }
+        }
+
+        private fun showLyricsLocal(file: File?) {
+            if (file != null) {
+                lyricsView.setLrcData(LrcHelper.parseLrcFromFile(file))
+            }
+        }
+    }
+}

app/src/main/java/io/github/muntashirakon/music/activities/MainActivity.kt

@@ -0,0 +1,697 @@
+package io.github.muntashirakon.music.activities
+
+import android.app.ActivityOptions
+import android.content.*
+import android.os.Bundle
+import android.provider.MediaStore
+import android.util.Log
+import android.view.Menu
+import android.view.MenuItem
+import android.view.SubMenu
+import android.view.View
+import androidx.core.app.ActivityCompat
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.commit
+import androidx.lifecycle.ViewModelProvider
+import code.name.monkey.appthemehelper.util.ATHUtil.resolveColor
+import code.name.monkey.appthemehelper.util.ToolbarContentTintHelper
+import io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.activities.base.AbsSlidingMusicPanelActivity
+import io.github.muntashirakon.music.dialogs.CreatePlaylistDialog.Companion.create
+import io.github.muntashirakon.music.fragments.LibraryViewModel
+import io.github.muntashirakon.music.fragments.albums.AlbumsFragment
+import io.github.muntashirakon.music.fragments.artists.ArtistsFragment
+import io.github.muntashirakon.music.fragments.base.AbsLibraryPagerRecyclerViewCustomGridSizeFragment
+import io.github.muntashirakon.music.fragments.genres.GenresFragment
+import io.github.muntashirakon.music.fragments.home.BannerHomeFragment
+import io.github.muntashirakon.music.fragments.mainactivity.FoldersFragment
+import io.github.muntashirakon.music.fragments.playlists.PlaylistsFragment
+import io.github.muntashirakon.music.fragments.queue.PlayingQueueFragment
+import io.github.muntashirakon.music.fragments.songs.SongsFragment
+import io.github.muntashirakon.music.helper.MusicPlayerRemote.isPlaying
+import io.github.muntashirakon.music.helper.MusicPlayerRemote.openAndShuffleQueue
+import io.github.muntashirakon.music.helper.MusicPlayerRemote.openQueue
+import io.github.muntashirakon.music.helper.MusicPlayerRemote.playFromUri
+import io.github.muntashirakon.music.helper.MusicPlayerRemote.shuffleMode
+import io.github.muntashirakon.music.helper.SearchQueryHelper.getSongs
+import io.github.muntashirakon.music.helper.SortOrder.*
+import io.github.muntashirakon.music.interfaces.CabHolder
+import io.github.muntashirakon.music.interfaces.MainActivityFragmentCallbacks
+import io.github.muntashirakon.music.loaders.AlbumLoader.getAlbum
+import io.github.muntashirakon.music.loaders.ArtistLoader.getArtist
+import io.github.muntashirakon.music.loaders.PlaylistSongsLoader.getPlaylistSongList
+import io.github.muntashirakon.music.model.Song
+import io.github.muntashirakon.music.service.MusicService
+import io.github.muntashirakon.music.util.AppRater.appLaunched
+import io.github.muntashirakon.music.util.NavigationUtil
+import io.github.muntashirakon.music.util.PreferenceUtil
+import io.github.muntashirakon.music.util.RetroColorUtil
+import io.github.muntashirakon.music.util.RetroUtil
+import com.afollestad.materialcab.MaterialCab
+import com.google.android.material.appbar.AppBarLayout
+import io.github.muntashirakon.music.*
+import kotlinx.android.synthetic.main.activity_main_content.*
+import java.util.*
+
+class MainActivity : AbsSlidingMusicPanelActivity(),
+    SharedPreferences.OnSharedPreferenceChangeListener, CabHolder {
+    companion object {
+        const val TAG = "MainActivity"
+        const val EXPAND_PANEL = "expand_panel"
+    }
+
+    lateinit var libraryViewModel: LibraryViewModel
+    private var cab: MaterialCab? = null
+    private val intentFilter = IntentFilter(Intent.ACTION_SCREEN_OFF)
+    private lateinit var currentFragment: MainActivityFragmentCallbacks
+    private var blockRequestPermissions = false
+    private val broadcastReceiver: BroadcastReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            val action = intent.action
+            if (action != null && action == Intent.ACTION_SCREEN_OFF) {
+                if (PreferenceUtil.isLockScreen && isPlaying) {
+                    val activity = Intent(context, LockScreenActivity::class.java)
+                    activity.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                    activity.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY)
+                    ActivityCompat.startActivity(context, activity, null)
+                }
+            }
+        }
+    }
+
+    override fun createContentView(): View {
+        return wrapSlidingMusicPanel(R.layout.activity_main_content)
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setLightNavigationBar(true)
+        setTaskDescriptionColorAuto()
+        hideStatusBar()
+        setBottomBarVisibility(View.VISIBLE)
+
+        libraryViewModel = ViewModelProvider(this).get(LibraryViewModel::class.java)
+        addMusicServiceEventListener(libraryViewModel)
+
+        if (savedInstanceState == null) {
+            selectedFragment(PreferenceUtil.lastPage)
+        } else {
+            restoreCurrentFragment()
+        }
+
+        appLaunched(this)
+        setupToolbar()
+        updateTabs()
+        getBottomNavigationView().selectedItemId = PreferenceUtil.lastPage
+        getBottomNavigationView().setOnNavigationItemSelectedListener {
+            PreferenceUtil.lastPage = it.itemId
+            selectedFragment(it.itemId)
+            true
+        }
+    }
+
+    override fun onResume() {
+        super.onResume()
+        registerReceiver(broadcastReceiver, intentFilter)
+        PreferenceUtil.registerOnSharedPreferenceChangedListener(this)
+        if (intent.hasExtra(EXPAND_PANEL) &&
+            intent.getBooleanExtra(EXPAND_PANEL, false) &&
+            PreferenceUtil.isExpandPanel
+        ) {
+            expandPanel()
+            intent.removeExtra(EXPAND_PANEL)
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        unregisterReceiver(broadcastReceiver)
+        PreferenceUtil.unregisterOnSharedPreferenceChangedListener(this)
+    }
+
+    override fun onPrepareOptionsMenu(menu: Menu?): Boolean {
+        ToolbarContentTintHelper.handleOnPrepareOptionsMenu(this, toolbar)
+        return super.onPrepareOptionsMenu(menu)
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
+        menuInflater.inflate(R.menu.menu_main, menu)
+        menu ?: return super.onCreateOptionsMenu(menu)
+        if (isPlaylistPage()) {
+            menu.add(0, R.id.action_new_playlist, 1, R.string.new_playlist_title)
+                .setIcon(R.drawable.ic_playlist_add_white_24dp)
+                .setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM)
+        }
+        if (isHomePage()) {
+            menu.add(0, R.id.action_mic, 1, getString(R.string.action_search))
+                .setIcon(R.drawable.ic_mic_white_24dp)
+                .setShowAsActionFlags(MenuItem.SHOW_AS_ACTION_IF_ROOM)
+        }
+        if (isFolderPage()) {
+            menu.add(0, R.id.action_scan, 0, R.string.scan_media)
+                .setIcon(R.drawable.ic_scanner_white_24dp)
+                .setShowAsActionFlags(MenuItem.SHOW_AS_ACTION_IF_ROOM)
+            menu.add(0, R.id.action_go_to_start_directory, 1, R.string.action_go_to_start_directory)
+                .setIcon(R.drawable.ic_bookmark_music_white_24dp)
+                .setShowAsActionFlags(MenuItem.SHOW_AS_ACTION_IF_ROOM)
+        }
+        val fragment: Fragment? = getCurrentFragment()
+        if (fragment != null && fragment is AbsLibraryPagerRecyclerViewCustomGridSizeFragment<*, *>) {
+            val gridSizeItem: MenuItem = menu.findItem(R.id.action_grid_size)
+            if (RetroUtil.isLandscape()) {
+                gridSizeItem.setTitle(R.string.action_grid_size_land)
+            }
+            setUpGridSizeMenu(fragment, gridSizeItem.subMenu)
+            setupLayoutMenu(fragment, menu.findItem(R.id.action_layout_type).subMenu)
+            setUpSortOrderMenu(fragment, menu.findItem(R.id.action_sort_order).subMenu)
+        } else {
+            menu.removeItem(R.id.action_layout_type)
+            menu.removeItem(R.id.action_grid_size)
+            menu.removeItem(R.id.action_sort_order)
+        }
+        menu.add(0, R.id.action_settings, 6, getString(R.string.action_settings))
+            .setIcon(R.drawable.ic_settings_white_24dp)
+            .setShowAsActionFlags(MenuItem.SHOW_AS_ACTION_IF_ROOM)
+        menu.add(0, R.id.action_search, 0, getString(R.string.action_search))
+            .setIcon(R.drawable.ic_search_white_24dp)
+            .setShowAsActionFlags(MenuItem.SHOW_AS_ACTION_ALWAYS)
+        ToolbarContentTintHelper.handleOnCreateOptionsMenu(
+            this,
+            toolbar,
+            menu,
+            getToolbarBackgroundColor(toolbar)
+        )
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        val fragment = getCurrentFragment()
+        if (fragment is AbsLibraryPagerRecyclerViewCustomGridSizeFragment<*, *>) {
+            if (handleGridSizeMenuItem(fragment, item)) {
+                return true
+            }
+            if (handleLayoutResType(fragment, item)) {
+                return true
+            }
+            if (handleSortOrderMenuItem(fragment, item)) {
+                return true
+            }
+        }
+        when (item.itemId) {
+            R.id.action_search -> NavigationUtil.goToSearch(this)
+            R.id.action_new_playlist -> {
+                create().show(supportFragmentManager, "CREATE_PLAYLIST")
+                return true
+            }
+            R.id.action_mic -> {
+                val options = ActivityOptions.makeSceneTransitionAnimation(
+                    this, toolbar,
+                    getString(R.string.transition_toolbar)
+                )
+                NavigationUtil.goToSearch(this, true, options)
+                return true
+            }
+            R.id.action_settings -> {
+                NavigationUtil.goToSettings(this)
+                return true
+            }
+        }
+        return super.onOptionsItemSelected(item)
+    }
+
+    private fun handleSortOrderMenuItem(
+        fragment: AbsLibraryPagerRecyclerViewCustomGridSizeFragment<*, *>,
+        item: MenuItem
+    ): Boolean {
+        var sortOrder: String? = null
+        when (fragment) {
+            is AlbumsFragment -> {
+                when (item.itemId) {
+                    R.id.action_album_sort_order_asc -> sortOrder = AlbumSortOrder.ALBUM_A_Z
+                    R.id.action_album_sort_order_desc -> sortOrder = AlbumSortOrder.ALBUM_Z_A
+                    R.id.action_album_sort_order_artist -> sortOrder = AlbumSortOrder.ALBUM_ARTIST
+                    R.id.action_album_sort_order_year -> sortOrder = AlbumSortOrder.ALBUM_YEAR
+                }
+            }
+            is ArtistsFragment -> {
+                when (item.itemId) {
+                    R.id.action_artist_sort_order_asc -> sortOrder = ArtistSortOrder.ARTIST_A_Z
+                    R.id.action_artist_sort_order_desc -> sortOrder = ArtistSortOrder.ARTIST_Z_A
+                }
+            }
+            is SongsFragment -> {
+                when (item.itemId) {
+                    R.id.action_song_sort_order_asc -> sortOrder = SongSortOrder.SONG_A_Z
+                    R.id.action_song_sort_order_desc -> sortOrder = SongSortOrder.SONG_Z_A
+                    R.id.action_song_sort_order_artist -> sortOrder = SongSortOrder.SONG_ARTIST
+                    R.id.action_song_sort_order_album -> sortOrder = SongSortOrder.SONG_ALBUM
+                    R.id.action_song_sort_order_year -> sortOrder = SongSortOrder.SONG_YEAR
+                    R.id.action_song_sort_order_date -> sortOrder = SongSortOrder.SONG_DATE
+                    R.id.action_song_sort_order_composer -> sortOrder = SongSortOrder.COMPOSER
+                    R.id.action_song_sort_order_date_modified ->
+                        sortOrder = SongSortOrder.SONG_DATE_MODIFIED
+                }
+            }
+        }
+
+        if (sortOrder != null) {
+            item.isChecked = true
+            fragment.setAndSaveSortOrder(sortOrder)
+            return true
+        }
+
+        return false
+    }
+
+    private fun handleLayoutResType(
+        fragment: AbsLibraryPagerRecyclerViewCustomGridSizeFragment<*, *>,
+        item: MenuItem
+    ): Boolean {
+        var layoutRes = -1
+        when (item.itemId) {
+            R.id.action_layout_normal -> layoutRes = R.layout.item_grid
+            R.id.action_layout_card -> layoutRes = R.layout.item_card
+            R.id.action_layout_colored_card -> layoutRes = R.layout.item_card_color
+            R.id.action_layout_circular -> layoutRes = R.layout.item_grid_circle
+            R.id.action_layout_image -> layoutRes = R.layout.image
+            R.id.action_layout_gradient_image -> layoutRes = R.layout.item_image_gradient
+        }
+        if (layoutRes != -1) {
+            item.isChecked = true
+            fragment.setAndSaveLayoutRes(layoutRes)
+            return true
+        }
+        return false
+    }
+
+    private fun handleGridSizeMenuItem(
+        fragment: AbsLibraryPagerRecyclerViewCustomGridSizeFragment<*, *>,
+        item: MenuItem
+    ): Boolean {
+        var gridSize = 0
+        when (item.itemId) {
+            R.id.action_grid_size_1 -> gridSize = 1
+            R.id.action_grid_size_2 -> gridSize = 2
+            R.id.action_grid_size_3 -> gridSize = 3
+            R.id.action_grid_size_4 -> gridSize = 4
+            R.id.action_grid_size_5 -> gridSize = 5
+            R.id.action_grid_size_6 -> gridSize = 6
+            R.id.action_grid_size_7 -> gridSize = 7
+            R.id.action_grid_size_8 -> gridSize = 8
+        }
+        if (gridSize > 0) {
+            item.isChecked = true
+            fragment.setAndSaveGridSize(gridSize)
+            return true
+        }
+        return false
+    }
+
+    private fun setUpGridSizeMenu(
+        fragment: AbsLibraryPagerRecyclerViewCustomGridSizeFragment<*, *>,
+        gridSizeMenu: SubMenu
+    ) {
+        when (fragment.getGridSize()) {
+            1 -> gridSizeMenu.findItem(R.id.action_grid_size_1).isChecked = true
+            2 -> gridSizeMenu.findItem(R.id.action_grid_size_2).isChecked = true
+            3 -> gridSizeMenu.findItem(R.id.action_grid_size_3).isChecked = true
+            4 -> gridSizeMenu.findItem(R.id.action_grid_size_4).isChecked = true
+            5 -> gridSizeMenu.findItem(R.id.action_grid_size_5).isChecked = true
+            6 -> gridSizeMenu.findItem(R.id.action_grid_size_6).isChecked = true
+            7 -> gridSizeMenu.findItem(R.id.action_grid_size_7).isChecked = true
+            8 -> gridSizeMenu.findItem(R.id.action_grid_size_8).isChecked = true
+        }
+        val maxGridSize = fragment.maxGridSize
+        if (maxGridSize < 8) {
+            gridSizeMenu.findItem(R.id.action_grid_size_8).isVisible = false
+        }
+        if (maxGridSize < 7) {
+            gridSizeMenu.findItem(R.id.action_grid_size_7).isVisible = false
+        }
+        if (maxGridSize < 6) {
+            gridSizeMenu.findItem(R.id.action_grid_size_6).isVisible = false
+        }
+        if (maxGridSize < 5) {
+            gridSizeMenu.findItem(R.id.action_grid_size_5).isVisible = false
+        }
+        if (maxGridSize < 4) {
+            gridSizeMenu.findItem(R.id.action_grid_size_4).isVisible = false
+        }
+        if (maxGridSize < 3) {
+            gridSizeMenu.findItem(R.id.action_grid_size_3).isVisible = false
+        }
+    }
+
+    private fun setupLayoutMenu(
+        fragment: AbsLibraryPagerRecyclerViewCustomGridSizeFragment<*, *>,
+        subMenu: SubMenu
+    ) {
+        when (fragment.itemLayoutRes()) {
+            R.layout.item_card ->
+                subMenu.findItem(R.id.action_layout_card).isChecked = true
+            R.layout.item_card_color ->
+                subMenu.findItem(R.id.action_layout_colored_card).isChecked = true
+            R.layout.item_grid_circle ->
+                subMenu.findItem(R.id.action_layout_circular).isChecked = true
+            R.layout.image ->
+                subMenu.findItem(R.id.action_layout_image).isChecked = true
+            R.layout.item_image_gradient ->
+                subMenu.findItem(R.id.action_layout_gradient_image).isChecked = true
+            R.layout.item_grid ->
+                subMenu.findItem(R.id.action_layout_normal).isChecked = true
+            else ->
+                subMenu.findItem(R.id.action_layout_normal).isChecked = true
+        }
+    }
+
+    private fun setUpSortOrderMenu(
+        fragment: AbsLibraryPagerRecyclerViewCustomGridSizeFragment<*, *>,
+        sortOrderMenu: SubMenu
+    ) {
+        val currentSortOrder = fragment.getSortOrder()
+        sortOrderMenu.clear()
+        when (fragment) {
+            is AlbumsFragment -> {
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_album_sort_order_asc,
+                    0,
+                    R.string.sort_order_a_z
+                ).isChecked = currentSortOrder == AlbumSortOrder.ALBUM_A_Z
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_album_sort_order_desc,
+                    1,
+                    R.string.sort_order_z_a
+                ).isChecked =
+                    currentSortOrder == AlbumSortOrder.ALBUM_Z_A
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_album_sort_order_artist,
+                    2,
+                    R.string.sort_order_artist
+                ).isChecked =
+                    currentSortOrder == AlbumSortOrder.ALBUM_ARTIST
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_album_sort_order_year,
+                    3,
+                    R.string.sort_order_year
+                ).isChecked =
+                    currentSortOrder == AlbumSortOrder.ALBUM_YEAR
+            }
+            is ArtistsFragment -> {
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_artist_sort_order_asc,
+                    0,
+                    R.string.sort_order_a_z
+                ).isChecked =
+                    currentSortOrder == ArtistSortOrder.ARTIST_A_Z
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_artist_sort_order_desc,
+                    1,
+                    R.string.sort_order_z_a
+                ).isChecked =
+                    currentSortOrder == ArtistSortOrder.ARTIST_Z_A
+            }
+            is SongsFragment -> {
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_song_sort_order_asc,
+                    0,
+                    R.string.sort_order_a_z
+                ).isChecked =
+                    currentSortOrder == SongSortOrder.SONG_A_Z
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_song_sort_order_desc,
+                    1,
+                    R.string.sort_order_z_a
+                ).isChecked =
+                    currentSortOrder == SongSortOrder.SONG_Z_A
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_song_sort_order_artist,
+                    2,
+                    R.string.sort_order_artist
+                ).isChecked =
+                    currentSortOrder == SongSortOrder.SONG_ARTIST
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_song_sort_order_album,
+                    3,
+                    R.string.sort_order_album
+                ).isChecked =
+                    currentSortOrder == SongSortOrder.SONG_ALBUM
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_song_sort_order_year,
+                    4,
+                    R.string.sort_order_year
+                ).isChecked =
+                    currentSortOrder == SongSortOrder.SONG_YEAR
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_song_sort_order_date,
+                    5,
+                    R.string.sort_order_date
+                ).isChecked =
+                    currentSortOrder == SongSortOrder.SONG_DATE
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_song_sort_order_date_modified,
+                    6,
+                    R.string.sort_order_date_modified
+                ).isChecked = currentSortOrder == SongSortOrder.SONG_DATE_MODIFIED
+                sortOrderMenu.add(
+                    0,
+                    R.id.action_song_sort_order_composer,
+                    7,
+                    R.string.sort_order_composer
+                ).isChecked = currentSortOrder == SongSortOrder.COMPOSER
+            }
+        }
+        sortOrderMenu.setGroupCheckable(0, true, true)
+    }
+
+    private fun getCurrentFragment(): Fragment? {
+        return supportFragmentManager.findFragmentById(R.id.fragment_container)
+    }
+
+    private fun isFolderPage(): Boolean {
+        return supportFragmentManager.findFragmentByTag(FoldersFragment.TAG) is FoldersFragment
+    }
+
+    private fun isHomePage(): Boolean {
+        return supportFragmentManager.findFragmentByTag(BannerHomeFragment.TAG) is BannerHomeFragment
+    }
+
+    private fun isPlaylistPage(): Boolean {
+        return supportFragmentManager.findFragmentByTag(PlaylistsFragment.TAG) is PlaylistsFragment
+    }
+
+    fun addOnAppBarOffsetChangedListener(
+        changedListener: AppBarLayout.OnOffsetChangedListener
+    ) {
+        appBarLayout.addOnOffsetChangedListener(changedListener)
+    }
+
+    fun removeOnAppBarOffsetChangedListener(
+        changedListener: AppBarLayout.OnOffsetChangedListener
+    ) {
+        appBarLayout.removeOnOffsetChangedListener(changedListener)
+    }
+
+    fun getTotalAppBarScrollingRange(): Int {
+        return appBarLayout.totalScrollRange
+    }
+
+    override fun requestPermissions() {
+        if (!blockRequestPermissions) {
+            super.requestPermissions()
+        }
+    }
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        super.onActivityResult(requestCode, resultCode, data)
+        if (!hasPermissions()) {
+            requestPermissions()
+        }
+    }
+
+    private fun setupToolbar() {
+        toolbar.setBackgroundColor(resolveColor(this, R.attr.colorSurface))
+        appBarLayout.setBackgroundColor(resolveColor(this, R.attr.colorSurface))
+        setSupportActionBar(toolbar)
+    }
+
+    private fun setCurrentFragment(
+        fragment: Fragment,
+        tag: String
+    ) {
+        supportFragmentManager.commit {
+            replace(R.id.fragment_container, fragment, tag)
+        }
+        currentFragment = fragment as MainActivityFragmentCallbacks
+    }
+
+    private fun selectedFragment(itemId: Int) {
+        when (itemId) {
+            R.id.action_album -> setCurrentFragment(
+                AlbumsFragment.newInstance(),
+                AlbumsFragment.TAG
+            )
+            R.id.action_artist -> setCurrentFragment(
+                ArtistsFragment.newInstance(),
+                ArtistsFragment.TAG
+            )
+            R.id.action_playlist -> setCurrentFragment(
+                PlaylistsFragment.newInstance(),
+                PlaylistsFragment.TAG
+            )
+            R.id.action_genre -> setCurrentFragment(
+                GenresFragment.newInstance(),
+                GenresFragment.TAG
+            )
+            R.id.action_playing_queue -> setCurrentFragment(
+                PlayingQueueFragment.newInstance(),
+                PlayingQueueFragment.TAG
+            )
+            R.id.action_song -> setCurrentFragment(
+                SongsFragment.newInstance(),
+                SongsFragment.TAG
+            )
+            R.id.action_folder -> setCurrentFragment(
+                FoldersFragment.newInstance(this),
+                FoldersFragment.TAG
+            )
+            R.id.action_home -> setCurrentFragment(
+                BannerHomeFragment.newInstance(),
+                BannerHomeFragment.TAG
+            )
+            else -> setCurrentFragment(
+                BannerHomeFragment.newInstance(),
+                BannerHomeFragment.TAG
+            )
+        }
+    }
+
+    private fun restoreCurrentFragment() {
+        val fragment = supportFragmentManager.findFragmentById(R.id.fragment_container)
+        if (fragment != null) {
+            currentFragment = fragment as MainActivityFragmentCallbacks
+        }
+    }
+
+    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()
+        handlePlaybackIntent(intent)
+    }
+
+    private fun handlePlaybackIntent(intent: Intent?) {
+        if (intent == null) {
+            return
+        }
+        val uri = intent.data
+        val mimeType = intent.type
+        var handled = false
+        if (intent.action != null && (intent.action == MediaStore.INTENT_ACTION_MEDIA_PLAY_FROM_SEARCH)
+        ) {
+            val songs: List<Song> =
+                getSongs(this, intent.extras!!)
+            if (shuffleMode == MusicService.SHUFFLE_MODE_SHUFFLE) {
+                openAndShuffleQueue(songs, true)
+            } else {
+                openQueue(songs, 0, true)
+            }
+            handled = true
+        }
+        if (uri != null && uri.toString().isNotEmpty()) {
+            playFromUri(uri)
+            handled = true
+        } else if (MediaStore.Audio.Playlists.CONTENT_TYPE == mimeType) {
+            val id = parseIdFromIntent(intent, "playlistId", "playlist").toInt()
+            if (id >= 0) {
+                val position = intent.getIntExtra("position", 0)
+                val songs: List<Song> =
+                    ArrayList(getPlaylistSongList(this, id))
+                openQueue(songs, position, true)
+                handled = true
+            }
+        } else if (MediaStore.Audio.Albums.CONTENT_TYPE == mimeType) {
+            val id = parseIdFromIntent(intent, "albumId", "album").toInt()
+            if (id >= 0) {
+                val position = intent.getIntExtra("position", 0)
+                openQueue(getAlbum(this, id).songs!!, position, true)
+                handled = true
+            }
+        } else if (MediaStore.Audio.Artists.CONTENT_TYPE == mimeType) {
+            val id = parseIdFromIntent(intent, "artistId", "artist").toInt()
+            if (id >= 0) {
+                val position = intent.getIntExtra("position", 0)
+                openQueue(getArtist(this, id).songs, position, true)
+                handled = true
+            }
+        }
+        if (handled) {
+            setIntent(Intent())
+        }
+    }
+
+    private fun parseIdFromIntent(
+        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) {
+                    Log.e(TAG, e.message)
+                }
+            }
+        }
+        return id
+    }
+
+    override fun handleBackPress(): Boolean {
+        if (cab != null && cab!!.isActive) {
+            cab?.finish()
+            return true
+        }
+        return super.handleBackPress() || currentFragment.handleBackPress()
+    }
+
+    override fun openCab(menuRes: Int, callback: MaterialCab.Callback): MaterialCab {
+        cab?.let {
+            if (it.isActive) it.finish()
+        }
+        cab = MaterialCab(this, R.id.cab_stub)
+            .setMenu(menuRes)
+            .setCloseDrawableRes(R.drawable.ic_close_white_24dp)
+            .setBackgroundColor(
+                RetroColorUtil.shiftBackgroundColorForLightText(
+                    resolveColor(
+                        this,
+                        R.attr.colorSurface
+                    )
+                )
+            )
+            .start(callback)
+        return cab as MaterialCab
+    }
+}

app/src/main/java/io/github/muntashirakon/music/activities/PlayingQueueActivity.kt

@@ -0,0 +1,187 @@
+package io.github.muntashirakon.music.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 io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.activities.base.AbsMusicServiceActivity
+import io.github.muntashirakon.music.adapter.song.PlayingQueueAdapter
+import io.github.muntashirakon.music.extensions.accentColor
+import io.github.muntashirakon.music.extensions.surfaceColor
+import io.github.muntashirakon.music.helper.MusicPlayerRemote
+import io.github.muntashirakon.music.util.MusicUtil
+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 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()
+                }
+            }
+        })
+        //ViewUtil.setUpFastScrollRecyclerViewColor(this, 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/io/github/muntashirakon/music/activities/PlaylistDetailActivity.kt

@@ -0,0 +1,245 @@
+package io.github.muntashirakon.music.activities
+
+import android.os.Bundle
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import code.name.monkey.appthemehelper.util.ATHUtil
+import io.github.muntashirakon.music.App
+import io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.activities.base.AbsSlidingMusicPanelActivity
+import io.github.muntashirakon.music.adapter.song.OrderablePlaylistSongAdapter
+import io.github.muntashirakon.music.adapter.song.PlaylistSongAdapter
+import io.github.muntashirakon.music.adapter.song.SongAdapter
+import io.github.muntashirakon.music.extensions.applyToolbar
+import io.github.muntashirakon.music.helper.menu.PlaylistMenuHelper
+import io.github.muntashirakon.music.interfaces.CabHolder
+import io.github.muntashirakon.music.loaders.PlaylistLoader
+import io.github.muntashirakon.music.model.AbsCustomPlaylist
+import io.github.muntashirakon.music.model.Playlist
+import io.github.muntashirakon.music.model.Song
+import io.github.muntashirakon.music.mvp.presenter.PlaylistSongsPresenter
+import io.github.muntashirakon.music.mvp.presenter.PlaylistSongsView
+import io.github.muntashirakon.music.util.DensityUtil
+import io.github.muntashirakon.music.util.PlaylistsUtil
+import io.github.muntashirakon.music.util.RetroColorUtil
+import com.afollestad.materialcab.MaterialCab
+import com.h6ah4i.android.widget.advrecyclerview.animator.RefactoredDefaultItemAnimator
+import com.h6ah4i.android.widget.advrecyclerview.draggable.RecyclerViewDragDropManager
+import com.h6ah4i.android.widget.advrecyclerview.utils.WrapperAdapterUtils
+import kotlinx.android.synthetic.main.activity_playlist_detail.*
+import javax.inject.Inject
+
+class PlaylistDetailActivity : AbsSlidingMusicPanelActivity(), CabHolder, PlaylistSongsView {
+
+    @Inject
+    lateinit var playlistSongsPresenter: PlaylistSongsPresenter
+
+    private lateinit var playlist: Playlist
+    private var cab: MaterialCab? = null
+    private lateinit var adapter: SongAdapter
+    private var wrappedAdapter: RecyclerView.Adapter<*>? = null
+    private var recyclerViewDragDropManager: RecyclerViewDragDropManager? = null
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setTaskDescriptionColorAuto()
+        setLightNavigationBar(true)
+        setBottomBarVisibility(View.GONE)
+
+        App.musicComponent.inject(this)
+        playlistSongsPresenter.attachView(this)
+
+        if (intent.extras != null) {
+            playlist = intent.extras!!.getParcelable(EXTRA_PLAYLIST)!!
+        } else {
+            finish()
+        }
+
+        setUpToolBar()
+        setUpRecyclerView()
+    }
+
+    override fun createContentView(): View {
+        return wrapSlidingMusicPanel(R.layout.activity_playlist_detail)
+    }
+
+    private fun setUpRecyclerView() {
+
+        recyclerView.layoutManager = LinearLayoutManager(this)
+        if (playlist is AbsCustomPlaylist) {
+            adapter = PlaylistSongAdapter(this, ArrayList(), R.layout.item_list, this)
+            recyclerView.adapter = adapter
+        } else {
+            recyclerViewDragDropManager = RecyclerViewDragDropManager()
+            val animator = RefactoredDefaultItemAnimator()
+            adapter = OrderablePlaylistSongAdapter(this,
+                ArrayList(),
+                R.layout.item_list,
+                this,
+                object : OrderablePlaylistSongAdapter.OnMoveItemListener {
+                    override fun onMoveItem(fromPosition: Int, toPosition: Int) {
+                        if (PlaylistsUtil.moveItem(
+                                this@PlaylistDetailActivity,
+                                playlist.id,
+                                fromPosition,
+                                toPosition
+                            )
+                        ) {
+                            val song = adapter.dataSet.removeAt(fromPosition)
+                            adapter.dataSet.add(toPosition, song)
+                            adapter.notifyItemMoved(fromPosition, toPosition)
+                        }
+                    }
+                })
+            wrappedAdapter = recyclerViewDragDropManager!!.createWrappedAdapter(adapter)
+
+            recyclerView.adapter = wrappedAdapter
+            recyclerView.itemAnimator = animator
+
+            recyclerViewDragDropManager?.attachRecyclerView(recyclerView)
+        }
+        adapter.registerAdapterDataObserver(object : RecyclerView.AdapterDataObserver() {
+            override fun onChanged() {
+                super.onChanged()
+                checkIsEmpty()
+            }
+        })
+    }
+
+    override fun onResume() {
+        super.onResume()
+        playlistSongsPresenter.loadPlaylistSongs(playlist)
+    }
+
+    private fun setUpToolBar() {
+        applyToolbar(toolbar)
+        title = playlist.name
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(
+            if (playlist is AbsCustomPlaylist) R.menu.menu_smart_playlist_detail
+            else R.menu.menu_playlist_detail, menu
+        )
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        when (item.itemId) {
+            android.R.id.home -> {
+                onBackPressed()
+                return true
+            }
+        }
+        return PlaylistMenuHelper.handleMenuClick(this, playlist, item)
+    }
+
+    override fun openCab(menuRes: Int, callback: MaterialCab.Callback): MaterialCab {
+        if (cab != null && cab!!.isActive) {
+            cab!!.finish()
+        }
+        cab = MaterialCab(this, R.id.cab_stub).setMenu(menuRes)
+            .setCloseDrawableRes(R.drawable.ic_close_white_24dp)
+            .setBackgroundColor(
+                RetroColorUtil.shiftBackgroundColorForLightText(
+                    ATHUtil.resolveColor(
+                        this,
+                        R.attr.colorSurface
+                    )
+                )
+            ).start(callback)
+        return cab!!
+    }
+
+    override fun onBackPressed() {
+        if (cab != null && cab!!.isActive) {
+            cab!!.finish()
+        } else {
+            recyclerView!!.stopScroll()
+            super.onBackPressed()
+        }
+    }
+
+    override fun onMediaStoreChanged() {
+        super.onMediaStoreChanged()
+        if (playlist !is AbsCustomPlaylist) {
+            // Playlist deleted
+            if (!PlaylistsUtil.doesPlaylistExist(this, playlist.id)) {
+                finish()
+                return
+            }
+            // Playlist renamed
+            val playlistName = PlaylistsUtil.getNameForPlaylist(this, playlist.id.toLong())
+            if (playlistName != playlist.name) {
+                playlist = PlaylistLoader.getPlaylist(this, playlist.id)
+                setToolbarTitle(playlist.name)
+            }
+        }
+        playlistSongsPresenter.loadPlaylistSongs(playlist)
+    }
+
+    private fun setToolbarTitle(title: String) {
+        supportActionBar?.title = title
+    }
+
+    private fun checkForPadding() {
+        val height = DensityUtil.dip2px(this, 52f)
+        recyclerView.setPadding(0, 0, 0, (height))
+    }
+
+    private fun checkIsEmpty() {
+        checkForPadding()
+        emptyEmoji.text = getEmojiByUnicode(0x1F631)
+        empty.visibility = if (adapter.itemCount == 0) View.VISIBLE else View.GONE
+        emptyText.visibility = if (adapter.itemCount == 0) View.VISIBLE else View.GONE
+    }
+
+    private fun getEmojiByUnicode(unicode: Int): String {
+        return String(Character.toChars(unicode))
+    }
+
+    public override fun onPause() {
+        if (recyclerViewDragDropManager != null) {
+            recyclerViewDragDropManager!!.cancelDrag()
+        }
+        super.onPause()
+    }
+
+    override fun onDestroy() {
+        if (recyclerViewDragDropManager != null) {
+            recyclerViewDragDropManager!!.release()
+            recyclerViewDragDropManager = null
+        }
+
+        if (recyclerView != null) {
+            recyclerView!!.itemAnimator = null
+            recyclerView!!.adapter = null
+        }
+
+        if (wrappedAdapter != null) {
+            WrapperAdapterUtils.releaseAll(wrappedAdapter)
+            wrappedAdapter = null
+        }
+        super.onDestroy()
+        playlistSongsPresenter.detachView()
+    }
+
+    override fun showEmptyView() {
+        empty.visibility = View.VISIBLE
+        emptyText.visibility = View.VISIBLE
+    }
+
+    override fun songs(songs: List<Song>) {
+        adapter.swapDataSet(songs)
+    }
+
+    companion object {
+        var EXTRA_PLAYLIST = "extra_playlist"
+    }
+}

app/src/main/java/io/github/muntashirakon/music/activities/SearchActivity.kt

@@ -0,0 +1,224 @@
+package io.github.muntashirakon.music.activities
+
+import android.app.Activity
+import android.app.Service
+import android.content.ActivityNotFoundException
+import android.content.Intent
+import android.content.res.ColorStateList
+import android.os.Bundle
+import android.speech.RecognizerIntent
+import android.text.Editable
+import android.text.TextWatcher
+import android.view.View
+import android.view.inputmethod.InputMethodManager
+import android.widget.TextView.BufferType
+import android.widget.Toast
+import androidx.appcompat.widget.SearchView.OnQueryTextListener
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.RecyclerView
+import androidx.transition.TransitionManager
+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 io.github.muntashirakon.music.App
+import io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.activities.base.AbsMusicServiceActivity
+import io.github.muntashirakon.music.adapter.SearchAdapter
+import io.github.muntashirakon.music.mvp.presenter.SearchPresenter
+import io.github.muntashirakon.music.mvp.presenter.SearchView
+import io.github.muntashirakon.music.util.RetroUtil
+import com.google.android.material.textfield.TextInputEditText
+import kotlinx.android.synthetic.main.activity_search.*
+import java.util.*
+import javax.inject.Inject
+import kotlin.collections.ArrayList
+
+class SearchActivity : AbsMusicServiceActivity(), OnQueryTextListener, TextWatcher, SearchView {
+    @Inject
+    lateinit var searchPresenter: SearchPresenter
+
+    private var searchAdapter: SearchAdapter? = null
+    private var query: String? = null
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_search)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setTaskDescriptionColorAuto()
+        setLightNavigationBar(true)
+
+        App.musicComponent.inject(this)
+        searchPresenter.attachView(this)
+
+        setupRecyclerView()
+        setUpToolBar()
+        setupSearchView()
+
+        if (intent.getBooleanExtra(EXTRA_SHOW_MIC, false)) {
+            startMicSearch()
+        }
+
+        back.setOnClickListener { onBackPressed() }
+        voiceSearch.setOnClickListener { startMicSearch() }
+        clearText.setOnClickListener { searchView.clearText() }
+        searchContainer.backgroundTintList =
+            ColorStateList.valueOf(ATHUtil.resolveColor(this, R.attr.colorSurface))
+
+        keyboardPopup.setOnClickListener {
+            val inputManager = getSystemService(Service.INPUT_METHOD_SERVICE) as InputMethodManager
+            inputManager.showSoftInput(searchView, InputMethodManager.SHOW_IMPLICIT)
+        }
+
+        keyboardPopup.backgroundTintList = ColorStateList.valueOf(ThemeStore.accentColor(this))
+        ColorStateList.valueOf(
+            MaterialValueHelper.getPrimaryTextColor(
+                this,
+                ColorUtil.isColorLight(ThemeStore.accentColor(this))
+            )
+        ).apply {
+            keyboardPopup.setTextColor(this)
+            keyboardPopup.iconTint = this
+        }
+        if (savedInstanceState != null) {
+            query = savedInstanceState.getString(QUERY)
+        }
+    }
+
+    private fun setupRecyclerView() {
+        searchAdapter = SearchAdapter(this, emptyList())
+        searchAdapter?.registerAdapterDataObserver(object : RecyclerView.AdapterDataObserver() {
+            override fun onChanged() {
+                super.onChanged()
+                empty.visibility = if (searchAdapter!!.itemCount < 1) View.VISIBLE else View.GONE
+            }
+        })
+        recyclerView.apply {
+            layoutManager = LinearLayoutManager(this@SearchActivity)
+            adapter = searchAdapter
+        }
+        recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
+            override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+                super.onScrolled(recyclerView, dx, dy)
+                if (dy > 0) {
+                    keyboardPopup.shrink()
+                } else if (dy < 0) {
+                    keyboardPopup.extend()
+                }
+            }
+        })
+    }
+
+    private fun setupSearchView() {
+        searchView.addTextChangedListener(this)
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        searchPresenter.detachView()
+    }
+
+    override fun onSaveInstanceState(outState: Bundle) {
+        super.onSaveInstanceState(outState)
+        outState.putString(QUERY, query)
+    }
+
+    private fun setUpToolBar() {
+        title = null
+    }
+
+    private fun search(query: String) {
+        this.query = query
+        TransitionManager.beginDelayedTransition(appBarLayout)
+        voiceSearch.visibility = if (query.isNotEmpty()) View.GONE else View.VISIBLE
+        clearText.visibility = if (query.isNotEmpty()) View.VISIBLE else View.GONE
+        searchPresenter.search(query)
+    }
+
+    override fun onMediaStoreChanged() {
+        super.onMediaStoreChanged()
+        query?.let { search(it) }
+    }
+
+    override fun onQueryTextSubmit(query: String): Boolean {
+        hideSoftKeyboard()
+        return false
+    }
+
+    override fun onQueryTextChange(newText: String): Boolean {
+        search(newText)
+        return false
+    }
+
+    private fun hideSoftKeyboard() {
+        RetroUtil.hideSoftKeyboard(this@SearchActivity)
+        if (searchView != null) {
+            searchView.clearFocus()
+        }
+    }
+
+    override fun showEmptyView() {
+        searchAdapter?.swapDataSet(ArrayList())
+    }
+
+    override fun showData(data: MutableList<Any>) {
+        searchAdapter?.swapDataSet(data)
+    }
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        super.onActivityResult(requestCode, resultCode, data)
+        when (requestCode) {
+            REQ_CODE_SPEECH_INPUT -> {
+                if (resultCode == Activity.RESULT_OK && null != data) {
+                    val result: ArrayList<String>? =
+                        data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS)
+                    query = result?.get(0)
+                    searchView.setText(query, BufferType.EDITABLE)
+                    searchPresenter.search(query!!)
+                }
+            }
+        }
+    }
+
+    private fun startMicSearch() {
+        val intent = Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH)
+        intent.putExtra(
+            RecognizerIntent.EXTRA_LANGUAGE_MODEL,
+            RecognizerIntent.LANGUAGE_MODEL_FREE_FORM
+        )
+        intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, Locale.getDefault())
+        intent.putExtra(RecognizerIntent.EXTRA_PROMPT, getString(R.string.speech_prompt))
+        try {
+            startActivityForResult(intent, REQ_CODE_SPEECH_INPUT)
+        } catch (e: ActivityNotFoundException) {
+            e.printStackTrace()
+            Toast.makeText(this, getString(R.string.speech_not_supported), Toast.LENGTH_SHORT)
+                .show()
+        }
+    }
+
+    override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {
+    }
+
+    override fun onTextChanged(newText: CharSequence, start: Int, before: Int, count: Int) {
+        search(newText.toString())
+    }
+
+    override fun afterTextChanged(s: Editable) {
+    }
+
+    companion object {
+        val TAG: String = SearchActivity::class.java.simpleName
+
+        const val EXTRA_SHOW_MIC = "extra_show_mic"
+        const val QUERY: String = "query"
+
+        private const val REQ_CODE_SPEECH_INPUT = 9002
+    }
+}
+
+fun TextInputEditText.clearText() {
+    text = null
+}

app/src/main/java/io/github/muntashirakon/music/activities/SettingsActivity.kt

@@ -0,0 +1,91 @@
+package io.github.muntashirakon.music.activities
+
+import android.os.Bundle
+import android.view.MenuItem
+import androidx.annotation.StringRes
+import androidx.fragment.app.Fragment
+import code.name.monkey.appthemehelper.ThemeStore
+import code.name.monkey.appthemehelper.util.VersionUtils
+import io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.activities.base.AbsBaseActivity
+import io.github.muntashirakon.music.appshortcuts.DynamicShortcutManager
+import io.github.muntashirakon.music.extensions.applyToolbar
+import io.github.muntashirakon.music.fragments.settings.MainSettingsFragment
+import com.afollestad.materialdialogs.color.ColorChooserDialog
+import kotlinx.android.synthetic.main.activity_settings.*
+
+class SettingsActivity : AbsBaseActivity(), ColorChooserDialog.ColorCallback {
+
+    private val fragmentManager = supportFragmentManager
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_settings)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setLightNavigationBar(true)
+        setupToolbar()
+
+        if (savedInstanceState == null) {
+            fragmentManager.beginTransaction().replace(R.id.contentFrame, MainSettingsFragment())
+                .commit()
+        }
+    }
+
+    private fun setupToolbar() {
+        setTitle(R.string.action_settings)
+        applyToolbar(toolbar)
+    }
+
+    fun setupFragment(fragment: Fragment, @StringRes titleName: Int) {
+        val fragmentTransaction = fragmentManager
+            .beginTransaction()
+            .setCustomAnimations(
+                R.anim.sliding_in_left,
+                R.anim.sliding_out_right,
+                android.R.anim.slide_in_left,
+                android.R.anim.slide_out_right
+            )
+        fragmentTransaction.replace(R.id.contentFrame, fragment, fragment.tag)
+        fragmentTransaction.addToBackStack(null)
+        fragmentTransaction.commit()
+        setTitle(titleName)
+    }
+
+    override fun onBackPressed() {
+        if (fragmentManager.backStackEntryCount == 0) {
+            super.onBackPressed()
+        } else {
+            setTitle(R.string.action_settings)
+            fragmentManager.popBackStack()
+        }
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        if (item.itemId == android.R.id.home) {
+            onBackPressed()
+            return true
+        }
+        return super.onOptionsItemSelected(item)
+    }
+
+    companion object {
+        const val TAG: String = "SettingsActivity"
+    }
+
+    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) {
+
+    }
+}

app/src/main/java/io/github/muntashirakon/music/activities/ShareInstagramStory.kt

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2020 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 io.github.muntashirakon.music.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 io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.activities.base.AbsBaseActivity
+import io.github.muntashirakon.music.glide.RetroMusicColoredTarget
+import io.github.muntashirakon.music.glide.SongGlideRequest
+import io.github.muntashirakon.music.model.Song
+import io.github.muntashirakon.music.util.Share
+import io.github.muntashirakon.music.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/io/github/muntashirakon/music/activities/UserInfoActivity.kt

@@ -0,0 +1,218 @@
+package io.github.muntashirakon.music.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.MaterialUtil
+import code.name.monkey.appthemehelper.util.MaterialValueHelper
+import io.github.muntashirakon.music.Constants.USER_BANNER
+import io.github.muntashirakon.music.Constants.USER_PROFILE
+import io.github.muntashirakon.music.activities.base.AbsBaseActivity
+import io.github.muntashirakon.music.extensions.accentColor
+import io.github.muntashirakon.music.extensions.applyToolbar
+import io.github.muntashirakon.music.glide.ProfileBannerGlideRequest
+import io.github.muntashirakon.music.glide.UserProfileGlideRequest
+import io.github.muntashirakon.music.util.ImageUtil
+import io.github.muntashirakon.music.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 io.github.muntashirakon.music.R
+import kotlinx.android.synthetic.main.activity_user_info.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.BufferedOutputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+
+class UserInfoActivity : AbsBaseActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_user_info)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setTaskDescriptionColorAuto()
+        setLightNavigationBar(true)
+        applyToolbar(toolbar)
+
+        MaterialUtil.setTint(nameContainer, false)
+        name.setText(PreferenceUtil.userName)
+
+        userImage.setOnClickListener {
+            pickNewPhoto()
+        }
+
+        bannerSelect.setOnClickListener {
+            selectBannerImage()
+        }
+
+        next.setOnClickListener {
+            val nameString = name.text.toString().trim { it <= ' ' }
+            if (TextUtils.isEmpty(nameString)) {
+                Toast.makeText(this, "Umm name is 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/io/github/muntashirakon/music/activities/WhatsNewActivity.java

@@ -0,0 +1,90 @@
+package io.github.muntashirakon.music.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 java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.Locale;
+
+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 io.github.muntashirakon.music.R;
+import io.github.muntashirakon.music.activities.base.AbsBaseActivity;
+import io.github.muntashirakon.music.util.PreferenceUtil;
+
+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/io/github/muntashirakon/music/activities/albums/AlbumDetailsActivity.kt

@@ -0,0 +1,401 @@
+package io.github.muntashirakon.music.activities.albums
+
+import android.app.ActivityOptions
+import android.content.Intent
+import android.os.Bundle
+import android.transition.Slide
+import android.view.Menu
+import android.view.MenuItem
+import android.view.SubMenu
+import android.view.View
+import android.widget.ImageView
+import androidx.core.app.ActivityCompat
+import androidx.lifecycle.ViewModelProvider
+import androidx.recyclerview.widget.DefaultItemAnimator
+import androidx.recyclerview.widget.GridLayoutManager
+import androidx.recyclerview.widget.LinearLayoutManager
+import code.name.monkey.appthemehelper.util.ATHUtil
+import code.name.monkey.appthemehelper.util.MaterialUtil
+import code.name.monkey.appthemehelper.util.ToolbarContentTintHelper
+import io.github.muntashirakon.music.activities.base.AbsSlidingMusicPanelActivity
+import io.github.muntashirakon.music.activities.tageditor.AbsTagEditorActivity
+import io.github.muntashirakon.music.activities.tageditor.AlbumTagEditorActivity
+import io.github.muntashirakon.music.adapter.album.HorizontalAlbumAdapter
+import io.github.muntashirakon.music.adapter.song.SimpleSongAdapter
+import io.github.muntashirakon.music.dialogs.AddToPlaylistDialog
+import io.github.muntashirakon.music.dialogs.DeleteSongsDialog
+import io.github.muntashirakon.music.extensions.extraNotNull
+import io.github.muntashirakon.music.extensions.ripAlpha
+import io.github.muntashirakon.music.extensions.show
+import io.github.muntashirakon.music.extensions.surfaceColor
+import io.github.muntashirakon.music.glide.AlbumGlideRequest
+import io.github.muntashirakon.music.glide.ArtistGlideRequest
+import io.github.muntashirakon.music.glide.RetroMusicColoredTarget
+import io.github.muntashirakon.music.helper.MusicPlayerRemote
+import io.github.muntashirakon.music.helper.SortOrder.AlbumSongSortOrder
+import io.github.muntashirakon.music.interfaces.CabHolder
+import io.github.muntashirakon.music.model.Album
+import io.github.muntashirakon.music.model.Artist
+import io.github.muntashirakon.music.mvp.presenter.AlbumDetailsView
+import io.github.muntashirakon.music.rest.model.LastFmAlbum
+import io.github.muntashirakon.music.util.*
+import io.github.muntashirakon.music.util.color.MediaNotificationProcessor
+import com.afollestad.materialcab.MaterialCab
+import com.bumptech.glide.Glide
+import io.github.muntashirakon.music.R
+import kotlinx.android.synthetic.main.activity_album.*
+import kotlinx.android.synthetic.main.activity_album_content.*
+import java.util.*
+import android.util.Pair as UtilPair
+
+class AlbumDetailsActivity : AbsSlidingMusicPanelActivity(), AlbumDetailsView, CabHolder {
+    override fun openCab(menuRes: Int, callback: MaterialCab.Callback): MaterialCab {
+        cab?.let {
+            if (it.isActive) it.finish()
+        }
+        cab = MaterialCab(this, R.id.cab_stub)
+            .setMenu(menuRes)
+            .setCloseDrawableRes(R.drawable.ic_close_white_24dp)
+            .setBackgroundColor(
+                RetroColorUtil.shiftBackgroundColorForLightText(
+                    ATHUtil.resolveColor(
+                        this,
+                        R.attr.colorSurface
+                    )
+                )
+            )
+            .start(callback)
+        return cab as MaterialCab
+    }
+
+    private lateinit var viewModel: AlbumDetailsViewModel
+    private lateinit var simpleSongAdapter: SimpleSongAdapter
+    private lateinit var album: Album
+    private lateinit var artistImage: ImageView
+    private var cab: MaterialCab? = null
+    private val savedSortOrder: String
+        get() = PreferenceUtil.albumDetailSongSortOrder
+
+    override fun createContentView(): View {
+        return wrapSlidingMusicPanel(R.layout.activity_album)
+    }
+
+    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 onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setTaskDescriptionColorAuto()
+        setLightNavigationBar(true)
+        setBottomBarVisibility(View.GONE)
+        window.sharedElementsUseOverlay = true
+        windowEnterTransition()
+
+        val albumId = extraNotNull<Int>(EXTRA_ALBUM_ID).value
+        ActivityCompat.postponeEnterTransition(this)
+        val viewModelFactory = AlbumDetailsViewModelFactory(application, albumId)
+        viewModel = ViewModelProvider(this, viewModelFactory).get(AlbumDetailsViewModel::class.java)
+        addMusicServiceEventListener(viewModel)
+        viewModel.getAlbum().observe(this, androidx.lifecycle.Observer {
+            ActivityCompat.startPostponedEnterTransition(this@AlbumDetailsActivity)
+            album(it)
+        })
+        viewModel.getArtist().observe(this, androidx.lifecycle.Observer {
+            loadArtistImage(it)
+        })
+        viewModel.getAlbumInfo().observe(this, androidx.lifecycle.Observer {
+            aboutAlbum(it)
+        })
+        setupRecyclerView()
+        artistImage = findViewById(R.id.artistImage)
+        artistImage.setOnClickListener {
+            val artistPairs = ActivityOptions.makeSceneTransitionAnimation(
+                this,
+                UtilPair.create(
+                    artistImage,
+                    getString(R.string.transition_artist_image)
+                )
+            )
+            NavigationUtil.goToArtistOptions(this, album.artistId, artistPairs)
+        }
+        playAction.apply {
+            setOnClickListener { MusicPlayerRemote.openQueue(album.songs!!, 0, true) }
+        }
+        shuffleAction.apply {
+            setOnClickListener { MusicPlayerRemote.openAndShuffleQueue(album.songs!!, true) }
+        }
+
+        aboutAlbumText.setOnClickListener {
+            if (aboutAlbumText.maxLines == 4) {
+                aboutAlbumText.maxLines = Integer.MAX_VALUE
+            } else {
+                aboutAlbumText.maxLines = 4
+            }
+        }
+    }
+
+    private fun setupRecyclerView() {
+        simpleSongAdapter = SimpleSongAdapter(this, ArrayList(), R.layout.item_song, this)
+        recyclerView.apply {
+            layoutManager = LinearLayoutManager(this@AlbumDetailsActivity)
+            itemAnimator = DefaultItemAnimator()
+            isNestedScrollingEnabled = false
+            adapter = simpleSongAdapter
+        }
+    }
+
+    override fun complete() {
+        ActivityCompat.startPostponedEnterTransition(this)
+    }
+
+    override fun album(album: Album) {
+        complete()
+        if (album.songs!!.isEmpty()) {
+            finish()
+            return
+        }
+        this.album = album
+
+        albumTitle.text = album.title
+        val songText =
+            resources.getQuantityString(
+                R.plurals.albumSongs,
+                album.songCount,
+                album.songCount
+            )
+        songTitle.text = songText
+
+        if (MusicUtil.getYearString(album.year) == "-") {
+            albumText.text = String.format(
+                "%s • %s",
+                album.artistName,
+                MusicUtil.getReadableDurationString(MusicUtil.getTotalDuration(album.songs))
+            )
+        } else {
+            albumText.text = String.format(
+                "%s • %s • %s",
+                album.artistName,
+                MusicUtil.getYearString(album.year),
+                MusicUtil.getReadableDurationString(MusicUtil.getTotalDuration(album.songs))
+            )
+        }
+        loadAlbumCover()
+        simpleSongAdapter.swapDataSet(album.songs)
+        viewModel.loadArtist(album.artistId)
+        viewModel.loadAlbumInfo(album)
+    }
+
+    override fun moreAlbums(albums: List<Album>) {
+        moreTitle.show()
+        moreRecyclerView.show()
+        moreTitle.text = String.format(getString(R.string.label_more_from), album.artistName)
+
+        val albumAdapter = HorizontalAlbumAdapter(this, albums, null)
+        moreRecyclerView.layoutManager = GridLayoutManager(
+            this,
+            1,
+            GridLayoutManager.HORIZONTAL,
+            false
+        )
+        moreRecyclerView.adapter = albumAdapter
+    }
+
+    override fun aboutAlbum(lastFmAlbum: LastFmAlbum) {
+        if (lastFmAlbum.album != null) {
+            if (lastFmAlbum.album.wiki != null) {
+                aboutAlbumText.show()
+                aboutAlbumTitle.show()
+                aboutAlbumTitle.text =
+                    String.format(getString(R.string.about_album_label), lastFmAlbum.album.name)
+                aboutAlbumText.text = lastFmAlbum.album.wiki.content
+            }
+            if (lastFmAlbum.album.listeners.isNotEmpty()) {
+                listeners.show()
+                listenersLabel.show()
+                scrobbles.show()
+                scrobblesLabel.show()
+
+                listeners.text = RetroUtil.formatValue(lastFmAlbum.album.listeners.toFloat())
+                scrobbles.text = RetroUtil.formatValue(lastFmAlbum.album.playcount.toFloat())
+            }
+        }
+    }
+
+    override fun loadArtistImage(artist: Artist) {
+        ArtistGlideRequest.Builder.from(Glide.with(this), artist)
+            .generatePalette(this)
+            .build()
+            .dontAnimate()
+            .dontTransform()
+            .into(object : RetroMusicColoredTarget(artistImage) {
+                override fun onColorReady(colors: MediaNotificationProcessor) {
+                }
+            })
+    }
+
+    private fun loadAlbumCover() {
+        AlbumGlideRequest.Builder.from(Glide.with(this), album.safeGetFirstSong())
+            .checkIgnoreMediaStore(this)
+            .ignoreMediaStore(PreferenceUtil.isIgnoreMediaStoreArtwork)
+            .generatePalette(this)
+            .build()
+            .dontAnimate()
+            .dontTransform()
+            .into(object : RetroMusicColoredTarget(image) {
+                override fun onColorReady(colors: MediaNotificationProcessor) {
+                    setColors(colors)
+                }
+            })
+    }
+
+    private fun setColors(color: MediaNotificationProcessor) {
+        val buttonColor = if (PreferenceUtil.isAdaptiveColor)
+            color.backgroundColor.ripAlpha()
+        else
+            ATHUtil.resolveColor(this, R.attr.colorSurface)
+
+        MaterialUtil.setTint(button = shuffleAction, color = buttonColor)
+        MaterialUtil.setTint(button = playAction, color = buttonColor)
+
+        toolbar.setBackgroundColor(surfaceColor())
+        setSupportActionBar(toolbar)
+        supportActionBar?.title = null
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.menu_album_detail, menu)
+        val sortOrder = menu.findItem(R.id.action_sort_order)
+        setUpSortOrderMenu(sortOrder.subMenu)
+        ToolbarContentTintHelper.handleOnCreateOptionsMenu(
+            this,
+            toolbar,
+            menu,
+            getToolbarBackgroundColor(toolbar)
+        )
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        return handleSortOrderMenuItem(item)
+    }
+
+    private fun handleSortOrderMenuItem(item: MenuItem): Boolean {
+        var sortOrder: String? = null
+        val songs = simpleSongAdapter.dataSet
+        when (item.itemId) {
+            R.id.action_play_next -> {
+                MusicPlayerRemote.playNext(songs)
+                return true
+            }
+            R.id.action_add_to_current_playing -> {
+                MusicPlayerRemote.enqueue(songs)
+                return true
+            }
+            R.id.action_add_to_playlist -> {
+                AddToPlaylistDialog.create(songs).show(supportFragmentManager, "ADD_PLAYLIST")
+                return true
+            }
+            R.id.action_delete_from_device -> {
+                DeleteSongsDialog.create(songs).show(supportFragmentManager, "DELETE_SONGS")
+                return true
+            }
+            android.R.id.home -> {
+                super.onBackPressed()
+                return true
+            }
+            R.id.action_tag_editor -> {
+                val intent = Intent(this, AlbumTagEditorActivity::class.java)
+                intent.putExtra(AbsTagEditorActivity.EXTRA_ID, album.id)
+                val options = ActivityOptions.makeSceneTransitionAnimation(
+                    this,
+                    albumCoverContainer,
+                    "${getString(R.string.transition_album_art)}_${album.id}"
+                )
+                startActivityForResult(
+                    intent,
+                    TAG_EDITOR_REQUEST, options.toBundle()
+                )
+                return true
+            }
+            /*Sort*/
+            R.id.action_sort_order_title -> sortOrder = AlbumSongSortOrder.SONG_A_Z
+            R.id.action_sort_order_title_desc -> sortOrder = AlbumSongSortOrder.SONG_Z_A
+            R.id.action_sort_order_track_list -> sortOrder = AlbumSongSortOrder.SONG_TRACK_LIST
+            R.id.action_sort_order_artist_song_duration ->
+                sortOrder = AlbumSongSortOrder.SONG_DURATION
+        }
+        if (sortOrder != null) {
+            item.isChecked = true
+            setSaveSortOrder(sortOrder)
+        }
+        return true
+    }
+
+    private fun setUpSortOrderMenu(sortOrder: SubMenu) {
+        when (savedSortOrder) {
+            AlbumSongSortOrder.SONG_A_Z -> sortOrder.findItem(R.id.action_sort_order_title)
+                .isChecked = true
+            AlbumSongSortOrder.SONG_Z_A -> sortOrder.findItem(R.id.action_sort_order_title_desc)
+                .isChecked = true
+            AlbumSongSortOrder.SONG_TRACK_LIST -> sortOrder.findItem(R.id.action_sort_order_track_list)
+                .isChecked = true
+            AlbumSongSortOrder.SONG_DURATION -> sortOrder.findItem(R.id.action_sort_order_artist_song_duration)
+                .isChecked = true
+        }
+    }
+
+    private fun setSaveSortOrder(sortOrder: String) {
+        PreferenceUtil.albumDetailSongSortOrder = sortOrder
+        when (sortOrder) {
+            AlbumSongSortOrder.SONG_TRACK_LIST -> album.songs?.sortWith(Comparator { o1, o2 ->
+                o1.trackNumber.compareTo(
+                    o2.trackNumber
+                )
+            })
+            AlbumSongSortOrder.SONG_A_Z -> album.songs?.sortWith(Comparator { o1, o2 ->
+                o1.title.compareTo(
+                    o2.title
+                )
+            })
+            AlbumSongSortOrder.SONG_Z_A -> album.songs?.sortWith(Comparator { o1, o2 ->
+                o2.title.compareTo(
+                    o1.title
+                )
+            })
+            AlbumSongSortOrder.SONG_DURATION -> album.songs?.sortWith(Comparator { o1, o2 ->
+                o1.duration.compareTo(
+                    o2.duration
+                )
+            })
+        }
+        album.songs?.let { simpleSongAdapter.swapDataSet(it) }
+    }
+
+
+    override fun onBackPressed() {
+        if (cab != null && cab!!.isActive) {
+            cab?.finish()
+        } else {
+            super.onBackPressed()
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        removeMusicServiceEventListener(viewModel)
+    }
+    companion object {
+
+        const val EXTRA_ALBUM_ID = "extra_album_id"
+        private const val TAG_EDITOR_REQUEST = 2001
+    }
+}

app/src/main/java/io/github/muntashirakon/music/activities/albums/AlbumDetailsViewModel.kt

@@ -0,0 +1,66 @@
+package io.github.muntashirakon.music.activities.albums
+
+import android.app.Application
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.viewModelScope
+import io.github.muntashirakon.music.interfaces.MusicServiceEventListener
+import io.github.muntashirakon.music.model.Album
+import io.github.muntashirakon.music.model.Artist
+import io.github.muntashirakon.music.providers.RepositoryImpl
+import io.github.muntashirakon.music.rest.model.LastFmAlbum
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.launch
+
+class AlbumDetailsViewModel(
+    application: Application,
+    private val albumId: Int
+) : AndroidViewModel(application), MusicServiceEventListener {
+    private val _repository = RepositoryImpl(application.applicationContext)
+    private val _album = MutableLiveData<Album>()
+    private val _artist = MutableLiveData<Artist>()
+    private val _lastFmAlbum = MutableLiveData<LastFmAlbum>()
+
+    fun getAlbum(): LiveData<Album> = _album
+    fun getArtist(): LiveData<Artist> = _artist
+    fun getAlbumInfo(): LiveData<LastFmAlbum> = _lastFmAlbum
+
+    init {
+        loadAlbumDetails()
+    }
+
+    private fun loadAlbumDetails() = viewModelScope.launch {
+        val album = loadAlbumAsync.await() ?: throw NullPointerException("Album couldn't found")
+        _album.postValue(album)
+    }
+
+    fun loadAlbumInfo(album: Album) = viewModelScope.launch(Dispatchers.IO) {
+        val lastFmAlbum = _repository.albumInfo(album.artistName ?: "-", album.title ?: "-")
+        _lastFmAlbum.postValue(lastFmAlbum)
+    }
+
+    fun loadArtist(artistId: Int) = viewModelScope.launch(Dispatchers.IO) {
+        val artist = _repository.artistById(artistId)
+        _artist.postValue(artist)
+    }
+
+    private val loadAlbumAsync: Deferred<Album?>
+        get() = viewModelScope.async(Dispatchers.IO) {
+            _repository.albumById(albumId)
+        }
+
+    override fun onMediaStoreChanged() {
+        loadAlbumDetails()
+    }
+
+    override fun onServiceConnected() {}
+    override fun onServiceDisconnected() {}
+    override fun onQueueChanged() {}
+    override fun onPlayingMetaChanged() {}
+    override fun onPlayStateChanged() {}
+    override fun onRepeatModeChanged() {}
+    override fun onShuffleModeChanged() {}
+}

app/src/main/java/io/github/muntashirakon/music/activities/albums/AlbumDetailsViewModelFactory.kt

@@ -0,0 +1,19 @@
+package io.github.muntashirakon.music.activities.albums
+
+import android.app.Application
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+
+class AlbumDetailsViewModelFactory(
+    private val application: Application,
+    private val albumId: Int
+) :
+    ViewModelProvider.AndroidViewModelFactory(application) {
+    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
+        return if (modelClass.isAssignableFrom(AlbumDetailsViewModel::class.java)) {
+            AlbumDetailsViewModel(application, albumId) as T
+        } else {
+            throw IllegalArgumentException("ViewModel Not Found")
+        }
+    }
+}

app/src/main/java/io/github/muntashirakon/music/activities/artists/ArtistDetailActivity.kt

@@ -0,0 +1,333 @@
+package io.github.muntashirakon.music.activities.artists
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Bundle
+import android.text.Spanned
+import android.transition.Slide
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import android.widget.Toast
+import androidx.core.app.ActivityCompat
+import androidx.core.text.HtmlCompat
+import androidx.lifecycle.ViewModelProvider
+import androidx.recyclerview.widget.DefaultItemAnimator
+import androidx.recyclerview.widget.GridLayoutManager
+import androidx.recyclerview.widget.LinearLayoutManager
+import code.name.monkey.appthemehelper.util.ATHUtil
+import code.name.monkey.appthemehelper.util.MaterialUtil
+import io.github.muntashirakon.music.activities.base.AbsSlidingMusicPanelActivity
+import io.github.muntashirakon.music.adapter.album.HorizontalAlbumAdapter
+import io.github.muntashirakon.music.adapter.song.SimpleSongAdapter
+import io.github.muntashirakon.music.dialogs.AddToPlaylistDialog
+import io.github.muntashirakon.music.extensions.extraNotNull
+import io.github.muntashirakon.music.extensions.ripAlpha
+import io.github.muntashirakon.music.extensions.show
+import io.github.muntashirakon.music.extensions.surfaceColor
+import io.github.muntashirakon.music.glide.ArtistGlideRequest
+import io.github.muntashirakon.music.glide.RetroMusicColoredTarget
+import io.github.muntashirakon.music.helper.MusicPlayerRemote
+import io.github.muntashirakon.music.interfaces.CabHolder
+import io.github.muntashirakon.music.model.Artist
+import io.github.muntashirakon.music.mvp.presenter.ArtistDetailsView
+import io.github.muntashirakon.music.rest.model.LastFmArtist
+import io.github.muntashirakon.music.util.*
+import io.github.muntashirakon.music.util.color.MediaNotificationProcessor
+import com.afollestad.materialcab.MaterialCab
+import com.bumptech.glide.Glide
+import io.github.muntashirakon.music.R
+import kotlinx.android.synthetic.main.activity_artist_content.*
+import kotlinx.android.synthetic.main.activity_artist_details.*
+import java.util.*
+import kotlin.collections.ArrayList
+
+class ArtistDetailActivity : AbsSlidingMusicPanelActivity(), ArtistDetailsView, CabHolder {
+    override fun openCab(menuRes: Int, callback: MaterialCab.Callback): MaterialCab {
+        cab?.let {
+            if (it.isActive) it.finish()
+        }
+        cab = MaterialCab(this, R.id.cab_stub)
+            .setMenu(menuRes)
+            .setCloseDrawableRes(R.drawable.ic_close_white_24dp)
+            .setBackgroundColor(
+                RetroColorUtil.shiftBackgroundColorForLightText(
+                    ATHUtil.resolveColor(
+                        this,
+                        R.attr.colorSurface
+                    )
+                )
+            )
+            .start(callback)
+        return cab as MaterialCab
+    }
+
+    private var cab: MaterialCab? = null
+    private var biography: Spanned? = null
+    private lateinit var artist: Artist
+    private lateinit var songAdapter: SimpleSongAdapter
+    private lateinit var albumAdapter: HorizontalAlbumAdapter
+    private var forceDownload: Boolean = false
+    private lateinit var viewModel: ArtistDetailsViewModel
+
+    override fun createContentView(): View {
+        return wrapSlidingMusicPanel(R.layout.activity_artist_details)
+    }
+
+    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 onCreate(savedInstanceState: Bundle?) {
+        setDrawUnderStatusBar()
+        super.onCreate(savedInstanceState)
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setTaskDescriptionColorAuto()
+        setLightNavigationBar(true)
+        setBottomBarVisibility(View.GONE)
+        window.sharedElementsUseOverlay = true
+        windowEnterTransition()
+
+        val artistId = extraNotNull<Int>(EXTRA_ARTIST_ID).value
+        val viewModelFactory = ArtistDetailsViewModelFactory(application, artistId)
+        viewModel =
+            ViewModelProvider(this, viewModelFactory).get(ArtistDetailsViewModel::class.java)
+        addMusicServiceEventListener(viewModel)
+        viewModel.getArtist().observe(this, androidx.lifecycle.Observer {
+            ActivityCompat.startPostponedEnterTransition(this@ArtistDetailActivity)
+            artist(it)
+        })
+        viewModel.getArtistInfo().observe(this, androidx.lifecycle.Observer {
+            artistInfo(it)
+        })
+        ActivityCompat.postponeEnterTransition(this)
+
+        setupRecyclerView()
+
+        playAction.apply {
+            setOnClickListener { MusicPlayerRemote.openQueue(artist.songs, 0, true) }
+        }
+        shuffleAction.apply {
+            setOnClickListener { MusicPlayerRemote.openAndShuffleQueue(artist.songs, true) }
+        }
+
+        biographyText.setOnClickListener {
+            if (biographyText.maxLines == 4) {
+                biographyText.maxLines = Integer.MAX_VALUE
+            } else {
+                biographyText.maxLines = 4
+            }
+        }
+    }
+
+    private fun setupRecyclerView() {
+        albumAdapter = HorizontalAlbumAdapter(this, ArrayList(), null)
+        albumRecyclerView.apply {
+            itemAnimator = DefaultItemAnimator()
+            layoutManager = GridLayoutManager(this.context, 1, GridLayoutManager.HORIZONTAL, false)
+            adapter = albumAdapter
+        }
+        songAdapter = SimpleSongAdapter(this, ArrayList(), R.layout.item_song, this)
+        recyclerView.apply {
+            itemAnimator = DefaultItemAnimator()
+            layoutManager = LinearLayoutManager(this.context)
+            adapter = songAdapter
+        }
+    }
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        super.onActivityResult(requestCode, resultCode, data)
+        when (requestCode) {
+            REQUEST_CODE_SELECT_IMAGE -> if (resultCode == Activity.RESULT_OK) {
+                data?.data?.let {
+                    CustomArtistImageUtil.getInstance(this).setCustomArtistImage(artist, it)
+                }
+            }
+            else -> if (resultCode == Activity.RESULT_OK) {
+                //reload()
+            }
+        }
+    }
+
+    override fun showEmptyView() {
+    }
+
+    override fun complete() {
+        ActivityCompat.startPostponedEnterTransition(this)
+    }
+
+    override fun artist(artist: Artist) {
+        complete()
+        if (artist.songCount <= 0) {
+            finish()
+        }
+        this.artist = artist
+        loadArtistImage()
+
+        if (RetroUtil.isAllowedToDownloadMetadata(this)) {
+            loadBiography(artist.name)
+        }
+        artistTitle.text = artist.name
+        text.text = String.format(
+            "%s • %s",
+            MusicUtil.getArtistInfoString(this, artist),
+            MusicUtil.getReadableDurationString(MusicUtil.getTotalDuration(artist.songs))
+        )
+        val songText =
+            resources.getQuantityString(
+                R.plurals.albumSongs,
+                artist.songCount,
+                artist.songCount
+            )
+        val albumText =
+            resources.getQuantityString(
+                R.plurals.albums,
+                artist.songCount,
+                artist.songCount
+            )
+        songTitle.text = songText
+        albumTitle.text = albumText
+        songAdapter.swapDataSet(artist.songs)
+        albumAdapter.swapDataSet(artist.albums!!)
+    }
+
+    private fun loadBiography(
+        name: String,
+        lang: String? = Locale.getDefault().language
+    ) {
+        biography = null
+        this.lang = lang
+        viewModel.loadBiography(name, lang, null)
+    }
+
+    override fun artistInfo(lastFmArtist: LastFmArtist?) {
+        if (lastFmArtist != null && lastFmArtist.artist != null) {
+            val bioContent = lastFmArtist.artist.bio.content
+            if (bioContent != null && bioContent.trim { it <= ' ' }.isNotEmpty()) {
+                biographyText.visibility = View.VISIBLE
+                biographyTitle.visibility = View.VISIBLE
+                biography = HtmlCompat.fromHtml(bioContent, HtmlCompat.FROM_HTML_MODE_LEGACY)
+                biographyText.text = biography
+                if (lastFmArtist.artist.stats.listeners.isNotEmpty()) {
+                    listeners.show()
+                    listenersLabel.show()
+                    scrobbles.show()
+                    scrobblesLabel.show()
+
+                    listeners.text =
+                        RetroUtil.formatValue(lastFmArtist.artist.stats.listeners.toFloat())
+                    scrobbles.text =
+                        RetroUtil.formatValue(lastFmArtist.artist.stats.playcount.toFloat())
+                }
+            }
+        }
+
+        // If the "lang" parameter is set and no biography is given, retry with default language
+        if (biography == null && lang != null) {
+            loadBiography(artist.name, null)
+        }
+    }
+
+    private var lang: String? = null
+
+    private fun loadArtistImage() {
+        ArtistGlideRequest.Builder.from(Glide.with(this), artist).generatePalette(this).build()
+            .dontAnimate().into(object : RetroMusicColoredTarget(image) {
+                override fun onColorReady(colors: MediaNotificationProcessor) {
+                    setColors(colors)
+                }
+            })
+    }
+
+    private fun setColors(color: MediaNotificationProcessor) {
+        val buttonColor = if (PreferenceUtil.isAdaptiveColor)
+            color.backgroundColor.ripAlpha()
+        else
+            ATHUtil.resolveColor(this, R.attr.colorSurface)
+
+        MaterialUtil.setTint(button = shuffleAction, color = buttonColor)
+        MaterialUtil.setTint(button = playAction, color = buttonColor)
+
+
+        toolbar.setBackgroundColor(surfaceColor())
+        setSupportActionBar(toolbar)
+        supportActionBar?.title = null
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        return handleSortOrderMenuItem(item)
+    }
+
+    private fun handleSortOrderMenuItem(item: MenuItem): Boolean {
+        val songs = artist.songs
+        when (item.itemId) {
+            android.R.id.home -> {
+                super.onBackPressed()
+                return true
+            }
+            R.id.action_play_next -> {
+                MusicPlayerRemote.playNext(songs)
+                return true
+            }
+            R.id.action_add_to_current_playing -> {
+                MusicPlayerRemote.enqueue(songs)
+                return true
+            }
+            R.id.action_add_to_playlist -> {
+                AddToPlaylistDialog.create(songs).show(supportFragmentManager, "ADD_PLAYLIST")
+                return true
+            }
+            R.id.action_set_artist_image -> {
+                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
+                )
+                return true
+            }
+            R.id.action_reset_artist_image -> {
+                Toast.makeText(
+                    this@ArtistDetailActivity,
+                    resources.getString(R.string.updating),
+                    Toast.LENGTH_SHORT
+                )
+                    .show()
+                CustomArtistImageUtil.getInstance(this@ArtistDetailActivity)
+                    .resetCustomArtistImage(artist)
+                forceDownload = true
+                return true
+            }
+        }
+        return true
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.menu_artist_detail, menu)
+        return super.onCreateOptionsMenu(menu)
+    }
+
+    override fun onBackPressed() {
+        if (cab != null && cab!!.isActive) {
+            cab?.finish()
+        } else {
+            super.onBackPressed()
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        removeMusicServiceEventListener(viewModel)
+    }
+
+    companion object {
+        const val EXTRA_ARTIST_ID = "extra_artist_id"
+        const val REQUEST_CODE_SELECT_IMAGE = 9003
+    }
+}

app/src/main/java/io/github/muntashirakon/music/activities/artists/ArtistDetailsViewModel.kt

@@ -0,0 +1,59 @@
+package io.github.muntashirakon.music.activities.artists
+
+import android.app.Application
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.viewModelScope
+import io.github.muntashirakon.music.interfaces.MusicServiceEventListener
+import io.github.muntashirakon.music.model.Artist
+import io.github.muntashirakon.music.providers.RepositoryImpl
+import io.github.muntashirakon.music.rest.model.LastFmArtist
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.launch
+
+class ArtistDetailsViewModel(
+    application: Application,
+    private val artistId: Int
+) : AndroidViewModel(application), MusicServiceEventListener {
+
+    private val loadArtistDetailsAsync: Deferred<Artist?>
+        get() = viewModelScope.async(Dispatchers.IO) {
+            _repository.artistById(artistId)
+        }
+    private val _repository = RepositoryImpl(application.applicationContext)
+    private val _artist = MutableLiveData<Artist>()
+    private val _lastFmArtist = MutableLiveData<LastFmArtist>()
+
+    fun getArtist(): LiveData<Artist> = _artist
+    fun getArtistInfo(): LiveData<LastFmArtist> = _lastFmArtist
+
+    init {
+        loadArtistDetails()
+    }
+
+    private fun loadArtistDetails() = viewModelScope.launch {
+        val artist =
+            loadArtistDetailsAsync.await() ?: throw NullPointerException("Album couldn't found")
+        _artist.postValue(artist)
+    }
+
+    fun loadBiography(name: String, lang: String?, cache: String?) = viewModelScope.launch {
+        val info = _repository.artistInfo(name, lang, cache)
+        _lastFmArtist.postValue(info)
+    }
+
+    override fun onMediaStoreChanged() {
+        loadArtistDetails()
+    }
+
+    override fun onServiceConnected() {}
+    override fun onServiceDisconnected() {}
+    override fun onQueueChanged() {}
+    override fun onPlayingMetaChanged() {}
+    override fun onPlayStateChanged() {}
+    override fun onRepeatModeChanged() {}
+    override fun onShuffleModeChanged() {}
+}

app/src/main/java/io/github/muntashirakon/music/activities/artists/ArtistDetailsViewModelFactory.kt

@@ -0,0 +1,19 @@
+package io.github.muntashirakon.music.activities.artists
+
+import android.app.Application
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+
+class ArtistDetailsViewModelFactory(
+    private val application: Application,
+    private val artistId: Int
+) :
+    ViewModelProvider.AndroidViewModelFactory(application) {
+    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
+        return if (modelClass.isAssignableFrom(ArtistDetailsViewModel::class.java)) {
+            ArtistDetailsViewModel(application, artistId) as T
+        } else {
+            throw IllegalArgumentException("ViewModel Not Found")
+        }
+    }
+}

app/src/main/java/io/github/muntashirakon/music/activities/base/AbsBaseActivity.kt

@@ -0,0 +1,147 @@
+package io.github.muntashirakon.music.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 com.google.android.material.snackbar.Snackbar
+import io.github.muntashirakon.music.R
+
+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/io/github/muntashirakon/music/activities/base/AbsMusicServiceActivity.kt

@@ -0,0 +1,170 @@
+package io.github.muntashirakon.music.activities.base
+
+import android.Manifest
+import android.content.*
+import android.os.Bundle
+import android.os.IBinder
+import io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.helper.MusicPlayerRemote
+import io.github.muntashirakon.music.interfaces.MusicServiceEventListener
+import io.github.muntashirakon.music.service.MusicService.*
+import java.lang.ref.WeakReference
+import java.util.*
+
+abstract class AbsMusicServiceActivity : AbsBaseActivity(), MusicServiceEventListener {
+
+    private val mMusicServiceEventListeners = ArrayList<MusicServiceEventListener>()
+
+    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(listener: MusicServiceEventListener?) {
+        if (listener != null) {
+            mMusicServiceEventListeners.add(listener)
+        }
+    }
+
+    fun removeMusicServiceEventListener(listener: MusicServiceEventListener?) {
+        if (listener != null) {
+            mMusicServiceEventListeners.remove(listener)
+        }
+    }
+
+    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()
+        }
+    }
+
+    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/io/github/muntashirakon/music/activities/base/AbsSlidingMusicPanelActivity.kt

@@ -0,0 +1,388 @@
+package io.github.muntashirakon.music.activities.base
+
+import android.animation.ValueAnimator
+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.annotation.LayoutRes
+import androidx.fragment.app.Fragment
+import code.name.monkey.appthemehelper.util.ATHUtil
+import code.name.monkey.appthemehelper.util.ColorUtil
+import io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.RetroBottomSheetBehavior
+import io.github.muntashirakon.music.extensions.hide
+import io.github.muntashirakon.music.extensions.show
+import io.github.muntashirakon.music.fragments.MiniPlayerFragment
+import io.github.muntashirakon.music.fragments.NowPlayingScreen
+import io.github.muntashirakon.music.fragments.NowPlayingScreen.*
+import io.github.muntashirakon.music.fragments.base.AbsPlayerFragment
+import io.github.muntashirakon.music.fragments.player.adaptive.AdaptiveFragment
+import io.github.muntashirakon.music.fragments.player.blur.BlurPlayerFragment
+import io.github.muntashirakon.music.fragments.player.card.CardFragment
+import io.github.muntashirakon.music.fragments.player.cardblur.CardBlurFragment
+import io.github.muntashirakon.music.fragments.player.circle.CirclePlayerFragment
+import io.github.muntashirakon.music.fragments.player.classic.ClassicPlayerFragment
+import io.github.muntashirakon.music.fragments.player.color.ColorFragment
+import io.github.muntashirakon.music.fragments.player.fit.FitFragment
+import io.github.muntashirakon.music.fragments.player.flat.FlatPlayerFragment
+import io.github.muntashirakon.music.fragments.player.full.FullPlayerFragment
+import io.github.muntashirakon.music.fragments.player.gradient.GradientPlayerFragment
+import io.github.muntashirakon.music.fragments.player.material.MaterialFragment
+import io.github.muntashirakon.music.fragments.player.normal.PlayerFragment
+import io.github.muntashirakon.music.fragments.player.peak.PeakPlayerFragment
+import io.github.muntashirakon.music.fragments.player.plain.PlainPlayerFragment
+import io.github.muntashirakon.music.fragments.player.simple.SimplePlayerFragment
+import io.github.muntashirakon.music.fragments.player.tiny.TinyPlayerFragment
+import io.github.muntashirakon.music.helper.MusicPlayerRemote
+import io.github.muntashirakon.music.model.CategoryInfo
+import io.github.muntashirakon.music.util.DensityUtil
+import io.github.muntashirakon.music.util.PreferenceUtil
+import io.github.muntashirakon.music.views.BottomNavigationBarTinted
+import com.google.android.material.bottomsheet.BottomSheetBehavior
+import com.google.android.material.shape.MaterialShapeDrawable
+import com.google.android.material.shape.ShapeAppearanceModel
+import kotlinx.android.synthetic.main.sliding_music_panel_layout.*
+
+abstract class AbsSlidingMusicPanelActivity : AbsMusicServiceActivity(),
+    AbsPlayerFragment.Callbacks {
+    companion object {
+        val TAG: String = AbsSlidingMusicPanelActivity::class.java.simpleName
+    }
+
+    private lateinit var behavior: RetroBottomSheetBehavior<FrameLayout>
+    private var miniPlayerFragment: MiniPlayerFragment? = null
+    private var playerFragment: AbsPlayerFragment? = null
+    private var cps: NowPlayingScreen? = null
+    private var navigationBarColor: Int = 0
+    private var taskColor: Int = 0
+    private var lightStatusBar: Boolean = false
+    private var lightNavigationBar: Boolean = false
+    private var navigationBarColorAnimator: ValueAnimator? = null
+    protected abstract fun createContentView(): View
+    private lateinit var shapeDrawable: MaterialShapeDrawable
+    private val panelState: Int
+        get() = behavior.state
+
+    private val bottomSheetCallbackList = object : BottomSheetBehavior.BottomSheetCallback() {
+
+        override fun onSlide(bottomSheet: View, slideOffset: Float) {
+            setMiniPlayerAlphaProgress(slideOffset)
+            dimBackground.show()
+            dimBackground.alpha = slideOffset
+            shapeDrawable.interpolation = 1 - slideOffset
+        }
+
+        override fun onStateChanged(bottomSheet: View, newState: Int) {
+            when (newState) {
+                BottomSheetBehavior.STATE_EXPANDED -> {
+                    onPanelExpanded()
+                }
+                BottomSheetBehavior.STATE_COLLAPSED -> {
+                    onPanelCollapsed()
+                    dimBackground.hide()
+                }
+                else -> {
+
+                }
+            }
+        }
+    }
+
+    fun getBottomSheetBehavior() = behavior
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(createContentView())
+        chooseFragmentForTheme()
+        setupSlidingUpPanel()
+
+
+
+        behavior = BottomSheetBehavior.from(slidingPanel) as RetroBottomSheetBehavior
+
+        val themeColor = ATHUtil.resolveColor(this, android.R.attr.windowBackground, Color.GRAY)
+        dimBackground.setBackgroundColor(ColorUtil.withAlpha(themeColor, 0.5f))
+        shapeDrawable = MaterialShapeDrawable(
+            ShapeAppearanceModel.builder(
+                this,
+                R.style.ClassicThemeOverLay,
+                0
+            ).build()
+        )
+        slidingPanel.background = shapeDrawable
+    }
+
+    override fun onResume() {
+        super.onResume()
+        if (cps != PreferenceUtil.nowPlayingScreen) {
+            postRecreate()
+        }
+        behavior.addBottomSheetCallback(bottomSheetCallbackList)
+
+        if (behavior.state == BottomSheetBehavior.STATE_EXPANDED) {
+            setMiniPlayerAlphaProgress(1f)
+        }
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        behavior.removeBottomSheetCallback(bottomSheetCallbackList)
+        if (navigationBarColorAnimator != null) navigationBarColorAnimator?.cancel() // just in case
+    }
+
+    protected fun wrapSlidingMusicPanel(@LayoutRes resId: Int): View {
+        val slidingMusicPanelLayout =
+            layoutInflater.inflate(R.layout.sliding_music_panel_layout, null)
+        val contentContainer =
+            slidingMusicPanelLayout.findViewById<ViewGroup>(R.id.mainContentFrame)
+        layoutInflater.inflate(resId, contentContainer)
+        return slidingMusicPanelLayout
+    }
+
+    private fun collapsePanel() {
+        behavior.state = BottomSheetBehavior.STATE_COLLAPSED
+    }
+
+    fun expandPanel() {
+        behavior.state = BottomSheetBehavior.STATE_EXPANDED
+        setMiniPlayerAlphaProgress(1f)
+    }
+
+    private fun setMiniPlayerAlphaProgress(progress: Float) {
+        if (miniPlayerFragment?.view == null) return
+        val alpha = 1 - progress
+        miniPlayerFragment?.view?.alpha = alpha
+        // necessary to make the views below clickable
+        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)
+
+
+        playerFragment?.setMenuVisibility(false)
+        playerFragment?.userVisibleHint = false
+        playerFragment?.onHide()
+    }
+
+    open fun onPanelExpanded() {
+        val playerFragmentColor = playerFragment!!.paletteColor
+        super.setTaskDescriptionColor(playerFragmentColor)
+
+        playerFragment?.setMenuVisibility(true)
+        playerFragment?.userVisibleHint = true
+        playerFragment?.onShow()
+        onPaletteColorChanged()
+    }
+
+    private fun setupSlidingUpPanel() {
+        slidingPanel.viewTreeObserver.addOnGlobalLayoutListener(object :
+            ViewTreeObserver.OnGlobalLayoutListener {
+            override fun onGlobalLayout() {
+                slidingPanel.viewTreeObserver.removeOnGlobalLayoutListener(this)
+                if (cps != Peak) {
+                    val params = slidingPanel.layoutParams as ViewGroup.LayoutParams
+                    params.height = ViewGroup.LayoutParams.MATCH_PARENT
+                    slidingPanel.layoutParams = params
+                }
+                when (panelState) {
+                    BottomSheetBehavior.STATE_EXPANDED -> onPanelExpanded()
+                    BottomSheetBehavior.STATE_COLLAPSED -> onPanelCollapsed()
+                    else -> playerFragment!!.onHide()
+                }
+            }
+        })
+    }
+
+    fun getBottomNavigationView(): BottomNavigationBarTinted {
+        return bottomNavigationView
+    }
+
+    fun setBottomBarVisibility(visible: Int) {
+        bottomNavigationView.visibility = visible
+        hideBottomBar(MusicPlayerRemote.playingQueue.isEmpty())
+    }
+
+    private fun hideBottomBar(hide: Boolean) {
+        val heightOfBar = resources.getDimensionPixelSize(R.dimen.mini_player_height)
+        val heightOfBarWithTabs =
+            resources.getDimensionPixelSize(R.dimen.mini_player_height_expanded)
+
+        if (hide) {
+            behavior.isHideable = true
+            behavior.peekHeight = 0
+            bottomNavigationView.elevation = DensityUtil.dip2px(this, 10f).toFloat()
+            collapsePanel()
+        } else {
+            if (MusicPlayerRemote.playingQueue.isNotEmpty()) {
+                slidingPanel.elevation = DensityUtil.dip2px(this, 10f).toFloat()
+                bottomNavigationView.elevation = DensityUtil.dip2px(this, 10f).toFloat()
+                behavior.isHideable = false
+                behavior.peekHeight =
+                    if (bottomNavigationView.visibility == View.VISIBLE) {
+                        heightOfBarWithTabs
+                    } else {
+                        heightOfBar
+                    }
+            }
+        }
+    }
+
+    private fun chooseFragmentForTheme() {
+        cps = PreferenceUtil.nowPlayingScreen
+        val fragment: Fragment = when (cps) {
+            Blur -> BlurPlayerFragment()
+            Adaptive -> AdaptiveFragment()
+            Normal -> PlayerFragment()
+            Card -> CardFragment()
+            BlurCard -> CardBlurFragment()
+            Fit -> FitFragment()
+            Flat -> FlatPlayerFragment()
+            Full -> FullPlayerFragment()
+            Plain -> PlainPlayerFragment()
+            Simple -> SimplePlayerFragment()
+            Material -> MaterialFragment()
+            Color -> ColorFragment()
+            Tiny -> TinyPlayerFragment()
+            Peak -> PeakPlayerFragment()
+            Circle -> CirclePlayerFragment()
+            Classic -> ClassicPlayerFragment()
+            Gradient -> GradientPlayerFragment()
+            else -> PlayerFragment()
+        } // must implement AbsPlayerFragment
+        supportFragmentManager.beginTransaction()
+            .replace(R.id.playerFragmentContainer, fragment)
+            .commit()
+        supportFragmentManager.executePendingTransactions()
+
+        playerFragment =
+            supportFragmentManager.findFragmentById(R.id.playerFragmentContainer) as AbsPlayerFragment
+        miniPlayerFragment =
+            supportFragmentManager.findFragmentById(R.id.miniPlayerFragment) as MiniPlayerFragment
+        miniPlayerFragment?.view?.setOnClickListener { expandPanel() }
+    }
+
+    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()
+    }
+
+    open fun handleBackPress(): Boolean {
+        if (behavior.peekHeight != 0 && playerFragment!!.onBackPressed()) return true
+        if (panelState == BottomSheetBehavior.STATE_EXPANDED) {
+            collapsePanel()
+            return true
+        }
+        return false
+    }
+
+    override fun onPaletteColorChanged() {
+        if (panelState == BottomSheetBehavior.STATE_EXPANDED) {
+            val paletteColor = playerFragment!!.paletteColor
+            super.setTaskDescriptionColor(paletteColor)
+
+            val isColorLight = ColorUtil.isColorLight(paletteColor)
+
+            if (PreferenceUtil.isAdaptiveColor && (cps == Normal || cps == Flat)) {
+                super.setLightNavigationBar(true)
+                super.setLightStatusbar(isColorLight)
+            } else if (cps == Card || cps == Blur || cps == BlurCard) {
+                super.setLightStatusbar(false)
+                super.setLightNavigationBar(true)
+                super.setNavigationbarColor(Color.BLACK)
+            } else if (cps == Color || cps == Tiny || cps == Gradient) {
+                super.setNavigationbarColor(paletteColor)
+                super.setLightNavigationBar(isColorLight)
+                super.setLightStatusbar(isColorLight)
+            } else if (cps == Full) {
+                super.setNavigationbarColor(paletteColor)
+                super.setLightNavigationBar(isColorLight)
+                super.setLightStatusbar(false)
+            } else if (cps == Classic) {
+                super.setLightStatusbar(false)
+            } else if (cps == 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 == BottomSheetBehavior.STATE_COLLAPSED) {
+            super.setLightStatusbar(enabled)
+        }
+    }
+
+    override fun setLightNavigationBar(enabled: Boolean) {
+        lightNavigationBar = enabled
+        if (panelState == BottomSheetBehavior.STATE_COLLAPSED) {
+            super.setLightNavigationBar(enabled)
+        }
+    }
+
+    override fun setNavigationbarColor(color: Int) {
+        navigationBarColor = color
+        if (panelState == BottomSheetBehavior.STATE_COLLAPSED) {
+            if (navigationBarColorAnimator != null) navigationBarColorAnimator!!.cancel()
+            super.setNavigationbarColor(color)
+        }
+    }
+
+    override fun setTaskDescriptionColor(color: Int) {
+        taskColor = color
+        if (panelState == BottomSheetBehavior.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()
+        }
+    }
+}

app/src/main/java/io/github/muntashirakon/music/activities/base/AbsThemeActivity.kt

@@ -0,0 +1,207 @@
+package io.github.muntashirakon.music.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 io.github.muntashirakon.music.LanguageContextWrapper
+import io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.util.PreferenceUtil
+import io.github.muntashirakon.music.util.RetroUtil
+import io.github.muntashirakon.music.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/io/github/muntashirakon/music/activities/bugreport/BugReportActivity.kt

@@ -0,0 +1,329 @@
+package io.github.muntashirakon.music.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 io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.activities.base.AbsThemeActivity
+import io.github.muntashirakon.music.activities.bugreport.model.DeviceInfo
+import io.github.muntashirakon.music.activities.bugreport.model.Report
+import io.github.muntashirakon.music.activities.bugreport.model.github.ExtraInfo
+import io.github.muntashirakon.music.activities.bugreport.model.github.GithubLogin
+import io.github.muntashirakon.music.activities.bugreport.model.github.GithubTarget
+import io.github.muntashirakon.music.misc.DialogAsyncTask
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+import com.google.android.material.floatingactionbutton.FloatingActionButton
+import com.google.android.material.textfield.TextInputLayout
+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
+import java.io.IOException
+
+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_white_24dp)
+                    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_white_24dp)
+                    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/io/github/muntashirakon/music/activities/bugreport/model/DeviceInfo.java

@@ -0,0 +1,133 @@
+package io.github.muntashirakon.music.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 io.github.muntashirakon.music.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(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>App version</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/io/github/muntashirakon/music/activities/bugreport/model/Report.java

@@ -0,0 +1,33 @@
+package io.github.muntashirakon.music.activities.bugreport.model;
+
+
+import io.github.muntashirakon.music.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/io/github/muntashirakon/music/activities/bugreport/model/github/ExtraInfo.java

@@ -0,0 +1,62 @@
+package io.github.muntashirakon.music.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/io/github/muntashirakon/music/activities/bugreport/model/github/GithubLogin.java

@@ -0,0 +1,41 @@
+package io.github.muntashirakon.music.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/io/github/muntashirakon/music/activities/bugreport/model/github/GithubTarget.java

@@ -0,0 +1,21 @@
+package io.github.muntashirakon.music.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/io/github/muntashirakon/music/activities/saf/SAFGuideActivity.java

@@ -0,0 +1,72 @@
+/*
+ * 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 io.github.muntashirakon.music.activities.saf;
+
+import android.os.Build;
+import android.os.Bundle;
+
+import androidx.annotation.Nullable;
+
+import com.heinrichreimersoftware.materialintro.app.IntroActivity;
+import com.heinrichreimersoftware.materialintro.slide.SimpleSlide;
+
+import io.github.muntashirakon.music.R;
+
+/**
+ * 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/io/github/muntashirakon/music/activities/tageditor/AbsTagEditorActivity.kt

@@ -0,0 +1,415 @@
+package io.github.muntashirakon.music.activities.tageditor
+
+import android.app.Activity
+import android.app.SearchManager
+import android.content.Intent
+import android.content.res.ColorStateList
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.net.Uri
+import android.os.Build
+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.ColorUtil
+import code.name.monkey.appthemehelper.util.MaterialValueHelper
+import code.name.monkey.appthemehelper.util.TintHelper
+import io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.R.drawable
+import io.github.muntashirakon.music.activities.base.AbsBaseActivity
+import io.github.muntashirakon.music.activities.saf.SAFGuideActivity
+import io.github.muntashirakon.music.util.RetroUtil
+import io.github.muntashirakon.music.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 java.io.File
+import java.util.*
+
+abstract class AbsTagEditorActivity : AbsBaseActivity() {
+
+    protected var id: Int = 0
+        private set
+    private var paletteColorPrimary: Int = 0
+    private var isInNoImageMode: Boolean = false
+    private var songPaths: List<String>? = null
+    lateinit var saveFab: MaterialButton
+
+    private var savedSongPaths: List<String>? = null
+    private val currentSongPath: String? = null
+    private var savedTags: Map<FieldKey, String>? = null
+    private var savedArtworkInfo: ArtworkInfo? = null
+
+    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()
+    protected abstract val contentViewLayout: Int
+
+    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)
+
+        saveFab = findViewById(R.id.saveTags)
+        getIntentExtras()
+
+        songPaths = getSongPaths()
+        if (songPaths!!.isEmpty()) {
+            finish()
+            return
+        }
+
+        setUpViews()
+
+        setStatusbarColorAuto()
+        setNavigationbarColorAuto()
+        setTaskDescriptionColorAuto()
+    }
+
+    private fun setUpViews() {
+        setUpScrollView()
+        setUpFab()
+        setUpImageView()
+    }
+
+    private fun setUpScrollView() {
+        //observableScrollView.setScrollViewCallbacks(observableScrollViewCallbacks);
+    }
+
+    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.backgroundTintList = ColorStateList.valueOf(ThemeStore.accentColor(this))
+        ColorStateList.valueOf(
+            MaterialValueHelper.getPrimaryTextColor(
+                this,
+                ColorUtil.isColorLight(
+                    ThemeStore.accentColor(
+                        this
+                    )
+                )
+            )
+        ).apply {
+            saveFab.setTextColor(this)
+            saveFab.iconTint = this
+        }
+        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.getInt(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()
+
+        savedSongPaths = getSongPaths()
+        savedTags = fieldKeyValueMap
+        savedArtworkInfo = artworkInfo
+
+        if (!SAFUtil.isSAFRequired(savedSongPaths)) {
+            writeTags(savedSongPaths)
+        } else {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+                if (SAFUtil.isSDCardAccessGranted(this)) {
+                    writeTags(savedSongPaths)
+                } else {
+                    startActivityForResult(
+                        Intent(this, SAFGuideActivity::class.java),
+                        SAFGuideActivity.REQUEST_CODE_SAF_GUIDE
+                    )
+                }
+            }
+        }
+    }
+
+    private fun writeTags(paths: List<String>?) {
+        WriteTagsAsyncTask(this).execute(
+            WriteTagsAsyncTask.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))
+                }
+            }
+        }
+    }
+
+    protected abstract fun loadImageFromFile(selectedFile: Uri?)
+
+    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()
+        }
+    }
+
+    class ArtworkInfo constructor(val albumId: Int, val artwork: Bitmap?)
+
+    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/io/github/muntashirakon/music/activities/tageditor/AlbumTagEditorActivity.kt

@@ -0,0 +1,198 @@
+package io.github.muntashirakon.music.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 io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.extensions.appHandleColor
+import io.github.muntashirakon.music.glide.palette.BitmapPaletteTranscoder
+import io.github.muntashirakon.music.glide.palette.BitmapPaletteWrapper
+import io.github.muntashirakon.music.loaders.AlbumLoader
+import io.github.muntashirakon.music.util.ImageUtil
+import io.github.muntashirakon.music.util.RetroColorUtil.generatePalette
+import io.github.muntashirakon.music.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 kotlinx.android.synthetic.main.activity_album_tag_editor.*
+import org.jaudiotagger.tag.FieldKey
+import java.util.*
+
+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(selectedFileUri: Uri?) {
+
+        Glide.with(this@AlbumTagEditorActivity).load(selectedFileUri).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,
+            if (deleteAlbumArt) AbsTagEditorActivity.ArtworkInfo(id, null)
+            else if (albumArtBitmap == null) null else ArtworkInfo(id, albumArtBitmap!!)
+        )
+    }
+
+    override fun getSongPaths(): List<String> {
+        val songs = AlbumLoader.getAlbum(this, id).songs
+        val paths = ArrayList<String>(songs!!.size)
+        for (song in songs) {
+            paths.add(song.data)
+        }
+        return paths
+    }
+
+    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/io/github/muntashirakon/music/activities/tageditor/SongTagEditorActivity.kt

@@ -0,0 +1,112 @@
+package io.github.muntashirakon.music.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 io.github.muntashirakon.music.R
+import io.github.muntashirakon.music.extensions.appHandleColor
+import io.github.muntashirakon.music.loaders.SongLoader
+import kotlinx.android.synthetic.main.activity_song_tag_editor.*
+import org.jaudiotagger.tag.FieldKey
+import java.util.*
+
+class SongTagEditorActivity : AbsTagEditorActivity(), TextWatcher {
+
+    override val contentViewLayout: Int
+        get() = R.layout.activity_song_tag_editor
+
+    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> {
+        val paths = ArrayList<String>(1)
+        paths.add(SongLoader.getSong(this, id).data)
+        return paths
+    }
+
+    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/io/github/muntashirakon/music/activities/tageditor/WriteTagsAsyncTask.java

@@ -0,0 +1,193 @@
+package io.github.muntashirakon.music.activities.tageditor;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.media.MediaScannerConnection;
+import android.net.Uri;
+import android.os.Build;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.google.android.material.dialog.MaterialAlertDialogBuilder;
+
+import org.jaudiotagger.audio.AudioFile;
+import org.jaudiotagger.audio.AudioFileIO;
+import org.jaudiotagger.tag.FieldKey;
+import org.jaudiotagger.tag.Tag;
+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.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+
+import io.github.muntashirakon.music.R;
+import io.github.muntashirakon.music.misc.DialogAsyncTask;
+import io.github.muntashirakon.music.misc.UpdateToastMediaScannerCompletionListener;
+import io.github.muntashirakon.music.util.MusicUtil;
+import io.github.muntashirakon.music.util.SAFUtil;
+
+public class WriteTagsAsyncTask extends
+        DialogAsyncTask<WriteTagsAsyncTask.LoadingInfo, Integer, String[]> {
+
+    private WeakReference<Activity> activity;
+
+    public WriteTagsAsyncTask(@NonNull Activity activity) {
+        super(activity);
+        this.activity = new WeakReference<>(activity);
+    }
+
+    @NonNull
+    @Override
+    protected Dialog createDialog(@NonNull Context context) {
+
+        return new MaterialAlertDialogBuilder(context)
+                .setTitle(R.string.saving_changes)
+                .setCancelable(false)
+                .setView(R.layout.loading)
+                .create();
+    }
+
+    @Override
+    protected String[] doInBackground(LoadingInfo... params) {
+        try {
+            LoadingInfo info = params[0];
+
+            Artwork artwork = null;
+            File albumArtFile = null;
+            if (info.artworkInfo != null && info.artworkInfo.getArtwork() != null) {
+                try {
+                    albumArtFile = MusicUtil.createAlbumArtFile().getCanonicalFile();
+                    info.artworkInfo.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.filePaths) {
+                publishProgress(++counter, info.filePaths.size());
+                try {
+                    Uri safUri = null;
+                    if (filePath.contains(SAFUtil.SEPARATOR)) {
+                        String[] fragments = filePath.split(SAFUtil.SEPARATOR);
+                        filePath = fragments[0];
+                        safUri = Uri.parse(fragments[1]);
+                    }
+
+                    AudioFile audioFile = AudioFileIO.read(new File(filePath));
+                    Tag tag = audioFile.getTagOrCreateAndSetDefault();
+
+                    if (info.fieldKeyValueMap != null) {
+                        for (Map.Entry<FieldKey, String> entry : info.fieldKeyValueMap.entrySet()) {
+                            try {
+                                tag.setField(entry.getKey(), entry.getValue());
+                            } catch (Exception e) {
+                                e.printStackTrace();
+                            }
+                        }
+                    }
+
+                    if (info.artworkInfo != null) {
+                        if (info.artworkInfo.getArtwork() == null) {
+                            tag.deleteArtworkField();
+                            deletedArtwork = true;
+                        } else if (artwork != null) {
+                            tag.deleteArtworkField();
+                            tag.setField(artwork);
+                            wroteArtwork = true;
+                        }
+                    }
+
+                    Activity activity = this.activity.get();
+                    SAFUtil.write(activity, audioFile, safUri);
+
+                } catch (@NonNull Exception e) {
+                    e.printStackTrace();
+                }
+            }
+
+            Context context = getContext();
+            if (context != null) {
+                if (wroteArtwork) {
+                    MusicUtil.insertAlbumArt(context, info.artworkInfo.getAlbumId(), albumArtFile.getPath());
+                } else if (deletedArtwork) {
+                    MusicUtil.deleteAlbumArt(context, info.artworkInfo.getAlbumId());
+                }
+            }
+
+            Collection<String> paths = info.filePaths;
+            if (Build.VERSION.SDK_INT == Build.VERSION_CODES.KITKAT) {
+                paths = new ArrayList<>(info.filePaths.size());
+                for (String path : info.filePaths) {
+                    if (path.contains(SAFUtil.SEPARATOR)) {
+                        path = path.split(SAFUtil.SEPARATOR)[0];
+                    }
+                    paths.add(path);
+                }
+            }
+
+            return paths.toArray(new String[paths.size()]);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    @Override
+    protected void onCancelled(String[] toBeScanned) {
+        super.onCancelled(toBeScanned);
+        scan(toBeScanned);
+    }
+
+    @Override
+    protected void onPostExecute(String[] toBeScanned) {
+        super.onPostExecute(toBeScanned);
+        scan(toBeScanned);
+    }
+
+    @Override
+    protected void onProgressUpdate(@NonNull Dialog dialog, Integer... values) {
+        super.onProgressUpdate(dialog, values);
+        //((MaterialDialog) dialog).setMaxProgress(values[1]);
+        //((MaterialDialog) dialog).setProgress(values[0]);
+    }
+
+    private void scan(String[] toBeScanned) {
+        Activity activity = this.activity.get();
+        if (activity != null) {
+            MediaScannerConnection.scanFile(activity, toBeScanned, null,
+                    new UpdateToastMediaScannerCompletionListener(activity, toBeScanned));
+        }
+    }
+
+    public static class LoadingInfo {
+
+        @Nullable
+        final Map<FieldKey, String> fieldKeyValueMap;
+
+        final Collection<String> filePaths;
+
+        @Nullable
+        private AbsTagEditorActivity.ArtworkInfo artworkInfo;
+
+        public LoadingInfo(Collection<String> filePaths,
+                           @Nullable Map<FieldKey, String> fieldKeyValueMap,
+                           @Nullable AbsTagEditorActivity.ArtworkInfo artworkInfo) {
+            this.filePaths = filePaths;
+            this.fieldKeyValueMap = fieldKeyValueMap;
+            this.artworkInfo = artworkInfo;
+        }
+    }
+}