<Merge> improve-lyrics-ui -> dev

app/src/main/java/player/phonograph/mediastore/LyricsLoader.kt

@@ -12,14 +12,16 @@ import player.phonograph.App
 import player.phonograph.model.Song
 import player.phonograph.model.lyrics.AbsLyrics
 import player.phonograph.model.lyrics.LrcLyrics
-import player.phonograph.model.lyrics.LyricsList
+import player.phonograph.model.lyrics.LyricsInfo
 import player.phonograph.model.lyrics.LyricsSource
 import player.phonograph.model.lyrics.TextLyrics
 import player.phonograph.settings.Setting
 import player.phonograph.util.FileUtil
 import player.phonograph.util.debug
 import player.phonograph.util.permissions.hasStorageReadPermission
 import player.phonograph.util.reportError
+import android.content.Context
+import android.net.Uri
 import android.util.Log
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -31,19 +33,19 @@ object LyricsLoader {
 
     private val backgroundCoroutine: CoroutineScope by lazy { CoroutineScope(Dispatchers.IO) }
 
-    suspend fun loadLyrics(songFile: File, song: Song): LyricsList {
+    suspend fun loadLyrics(songFile: File, song: Song): LyricsInfo {
         if (!Setting.instance.enableLyrics) {
             debug {
                 Log.v(TAG, "Lyrics is off for ${song.title}")
             }
-            return LyricsList()
+            return LyricsInfo.EMPTY
         }
 
         if (!hasStorageReadPermission(App.instance)) {
             debug {
                 Log.v(TAG, "No storage read permission to fetch lyrics for ${song.title}")
             }
-            return LyricsList()
+            return LyricsInfo.EMPTY
         }
 
         // embedded
@@ -73,8 +75,10 @@ object LyricsLoader {
             addAll(vagueLyrics)
         }
 
+        val activated: Int = resultList.indexOfFirst { it is LrcLyrics }
+
         // end of fetching
-        return LyricsList(resultList)
+        return LyricsInfo(song, resultList, activated)
     }
 
     private fun parseEmbedded(
@@ -185,5 +189,15 @@ object LyricsLoader {
         }
     }
 
+
+    fun parseFromUri(context: Context, uri: Uri): AbsLyrics? {
+        return context.contentResolver.openInputStream(uri)?.use { inputStream ->
+            inputStream.reader().use {
+                parse(it.readText(), LyricsSource.ManuallyLoaded())
+            }
+        }
+    }
+
+
     private const val TAG = "LyricsLoader"
 }

app/src/main/java/player/phonograph/misc/LyricsUpdater.kt

@@ -33,7 +33,7 @@ class LyricsUpdater(song: Song?) {
             if (!file.exists()) return@also
             runBlocking(exceptionHandler) {
                 LyricsLoader.loadLyrics(file, song).let {
-                    fetcher = LyricsFetcher(it.getLrcLyrics())
+                    fetcher = LyricsFetcher(it.firstLrcLyrics())
                 }
             }
         }

app/src/main/java/player/phonograph/model/lyrics/LyricsInfo.kt

@@ -0,0 +1,68 @@
+/*
+ *  Copyright (c) 2022~2023 chr_56
+ */
+
+package player.phonograph.model.lyrics
+
+import player.phonograph.model.Song
+import android.os.Parcelable
+import kotlinx.parcelize.Parcelize
+
+
+@Parcelize
+data class LyricsInfo(
+    val linkedSong: Song,
+    private val lyricsList: ArrayList<AbsLyrics>,
+    private val activatedLyricsNumber: Int,
+) : Parcelable, List<AbsLyrics> by lyricsList {
+
+
+    fun firstLrcLyrics(): LrcLyrics? = findFirst<LrcLyrics>()
+    fun firstTextLyrics(): TextLyrics? = findFirst<TextLyrics>()
+    fun allLyricsFrom(source: LyricsSource): List<AbsLyrics> = lyricsList.filter { it.source == source }
+    fun firstLyricsFrom(source: LyricsSource): AbsLyrics? = allLyricsFrom(source).firstOrNull()
+    fun availableSources(): Set<LyricsSource> = lyricsList.map { it.source }.toSet()
+    val activatedLyrics: AbsLyrics? get() = lyricsList.getOrNull(activatedLyricsNumber)
+
+    fun isActive(index: Int) = index == activatedLyricsNumber
+
+    private inline fun <reified L> findFirst(): L? {
+        for (lyric in lyricsList) {
+            if (lyric is L) return lyric
+        }
+        return null
+    }
+
+    fun createAmended(absLyrics: AbsLyrics): LyricsInfo = insect(this, absLyrics)
+
+    fun replaceActivated(index: Int): LyricsInfo = setActive(this, index)
+    fun replaceActivated(lyrics: AbsLyrics): LyricsInfo? = setActive(this, lyrics)
+
+    companion object {
+        val EMPTY = LyricsInfo(Song.EMPTY_SONG, ArrayList(), -1)
+
+        private fun insect(old: LyricsInfo, newLyrics: AbsLyrics): LyricsInfo =
+            LyricsInfo(
+                old.linkedSong,
+                ArrayList(old.lyricsList).also { it.add(newLyrics) },
+                old.activatedLyricsNumber
+            )
+
+        private fun setActive(old: LyricsInfo, index: Int): LyricsInfo =
+            LyricsInfo(
+                old.linkedSong,
+                old.lyricsList,
+                index
+            )
+
+        private fun setActive(old: LyricsInfo, lyrics: AbsLyrics): LyricsInfo? {
+            var index = -1
+            for ((i, l) in old.lyricsList.withIndex()) {
+                if (l === lyrics) {
+                    index = i
+                }
+            }
+            return if (index > -1) setActive(old, index) else null
+        }
+    }
+}

app/src/main/java/player/phonograph/model/lyrics/LyricsSource.kt

@@ -4,19 +4,31 @@
 
 package player.phonograph.model.lyrics
 
+import player.phonograph.R
+import android.content.Context
+
 @JvmInline
 value class LyricsSource(val type: Int = UNKNOWN_SOURCE) {
     @Suppress("FunctionName")
     companion object {
         fun Embedded() = LyricsSource(EMBEDDED)
         fun ExternalPrecise() = LyricsSource(EXTERNAL_PRECISE)
         fun ExternalDecorated() = LyricsSource(EXTERNAL_DECORATED)
+        fun ManuallyLoaded() = LyricsSource(MANUALLY_LOADED)
 
         const val EMBEDDED = 0
         const val EXTERNAL_PRECISE = 1
         const val EXTERNAL_DECORATED = 2
+        const val MANUALLY_LOADED = 4
 
         fun Unknown() = LyricsSource(UNKNOWN_SOURCE)
         const val UNKNOWN_SOURCE = -1
     }
+
+    fun name(context: Context): String = when (type) {
+        EMBEDDED                             -> context.getString(R.string.embedded_lyrics)
+        EXTERNAL_DECORATED, EXTERNAL_PRECISE -> context.getString(R.string.external_lyrics)
+        MANUALLY_LOADED                      -> context.getString(R.string.loaded)
+        else                                 -> "unknown"
+    }
 }