Merge pull request #2082 from Amonoman/master

Enhance library performance, genre separation, and better TTML support

Author: theovilardo

.github/workflows/codeql.yml

@@ -32,17 +32,22 @@ jobs:
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v6
 
+      - name: Pin Kotlin version for CodeQL compatibility
+        # CodeQL does not yet support Kotlin 2.4.0 (max: 2.3.x).
+        # This overrides the version only for this CI job without touching source files.
+        # TODO: remove once CodeQL adds Kotlin 2.4.0 support.
+        run: echo "kotlin.version=2.3.20" >> gradle.properties
+
       - name: Initialize CodeQL
         uses: github/codeql-action/init@v4
         with:
           languages: java-kotlin
           build-mode: manual
 
       - name: Build with Gradle
-        run: ./gradlew assembleDebug # Use the wrapper for consistency
+        run: ./gradlew assembleDebug
 
       - name: Perform CodeQL Analysis
         uses: github/codeql-action/analyze@v4
         with:
-          # Match the languages defined in the init step
           category: "/language:java-kotlin"

app/src/main/java/com/theveloper/pixelplay/data/database/MusicDao.kt

@@ -1552,6 +1552,35 @@ interface MusicDao {
         applyDirectoryFilter: Boolean
     ): Flow<List<SongEntity>>
 
+    // Multi-genre aware query: matches songs where the genre column equals the name (case-
+    // insensitively, via LIKE), or contains it as part of a comma-separated list.
+    // SQLite LIKE is case-insensitive for ASCII letters by default, which is sufficient
+    // for genre names. All six arms use LIKE so that "rock" matches "Rock", "Rock,Pop",
+    // "Rock, Pop", "Pop,Rock", "Pop, Rock", and "Pop,Rock,Jazz".
+    @Query("""
+        SELECT * FROM songs
+        WHERE (:applyDirectoryFilter = 0 OR id < 0 OR parent_directory_path IN (:allowedParentDirs))
+        AND (
+            genre LIKE :genreName
+            OR genre LIKE :genrePrefix
+            OR genre LIKE :genreSuffixWithSpace
+            OR genre LIKE :genreSuffix
+            OR genre LIKE :genreMiddleWithSpace
+            OR genre LIKE :genreMiddle
+        )
+        ORDER BY title ASC
+    """)
+    fun getSongsByGenreContaining(
+        genreName: String,
+        genrePrefix: String,
+        genreSuffixWithSpace: String,
+        genreSuffix: String,
+        genreMiddleWithSpace: String,
+        genreMiddle: String,
+        allowedParentDirs: List<String>,
+        applyDirectoryFilter: Boolean
+    ): Flow<List<SongEntity>>
+
     @Query("""
         SELECT * FROM songs
         WHERE (:applyDirectoryFilter = 0 OR id < 0 OR parent_directory_path IN (:allowedParentDirs))

app/src/main/java/com/theveloper/pixelplay/data/preferences/EqualizerPreferencesRepository.kt

@@ -39,17 +39,17 @@ class EqualizerPreferencesRepository @Inject constructor(
         val PINNED_PRESETS = stringPreferencesKey("pinned_presets_json")
     }
 
-    val equalizerViewModeFlow: Flow<UserPreferencesRepository.EqualizerViewMode> = dataStore.data.map { preferences ->
+    val equalizerViewModeFlow: Flow<EqualizerViewMode> = dataStore.data.map { preferences ->
         val modeString = preferences[Keys.VIEW_MODE]
         if (modeString != null) {
             try {
-                UserPreferencesRepository.EqualizerViewMode.valueOf(modeString)
+                EqualizerViewMode.valueOf(modeString)
             } catch (_: Exception) {
-                UserPreferencesRepository.EqualizerViewMode.SLIDERS
+                EqualizerViewMode.SLIDERS
             }
         } else {
             val isGraph = preferences[booleanPreferencesKey("is_graph_view")] ?: false
-            if (isGraph) UserPreferencesRepository.EqualizerViewMode.GRAPH else UserPreferencesRepository.EqualizerViewMode.SLIDERS
+            if (isGraph) EqualizerViewMode.GRAPH else EqualizerViewMode.SLIDERS
         }
     }
 
@@ -141,7 +141,7 @@ class EqualizerPreferencesRepository @Inject constructor(
         }
     }
 
-    suspend fun setEqualizerViewMode(mode: UserPreferencesRepository.EqualizerViewMode) =
+    suspend fun setEqualizerViewMode(mode: EqualizerViewMode) =
         dataStore.edit { preferences ->
             preferences[Keys.VIEW_MODE] = mode.name
         }

app/src/main/java/com/theveloper/pixelplay/data/preferences/EqualizerViewMode.kt

@@ -0,0 +1,5 @@
+package com.theveloper.pixelplay.data.preferences
+
+enum class EqualizerViewMode {
+    SLIDERS, GRAPH, HYBRID
+}

app/src/main/java/com/theveloper/pixelplay/data/preferences/UserPreferencesRepository.kt

@@ -53,8 +53,29 @@ import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.sync.Semaphore
 import kotlinx.coroutines.sync.withPermit
 
+private val EMBEDDED_LYRICS_KEYS = listOf("LYRICS", "SYNCEDLYRICS", "TTML", "UNSYNCEDLYRICS")
+
 private fun Lyrics.isValid(): Boolean = !synced.isNullOrEmpty() || !plain.isNullOrEmpty()
 
+internal fun parseBestEmbeddedLyricsField(propertyMap: Map<String, Array<String>>?): Lyrics? {
+    var firstPlainLyrics: Lyrics? = null
+
+    EMBEDDED_LYRICS_KEYS.forEach { key ->
+        propertyMap?.get(key).orEmpty().forEach { field ->
+            if (field.isBlank()) return@forEach
+
+            val parsedLyrics = LyricsUtils.parseLyrics(field)
+            if (!parsedLyrics.isValid()) return@forEach
+
+            val localLyrics = parsedLyrics.copy(areFromRemote = false)
+            if (!localLyrics.synced.isNullOrEmpty()) return localLyrics
+            if (firstPlainLyrics == null) firstPlainLyrics = localLyrics
+        }
+    }
+
+    return firstPlainLyrics
+}
+
 /**
  * LyricsData for JSON disk cache (matches Rhythm's format)
  */
@@ -1082,17 +1103,11 @@ class LyricsRepositoryImpl @Inject constructor(
                 ParcelFileDescriptor.open(tempFile, ParcelFileDescriptor.MODE_READ_ONLY).use { fd ->
                     val metadata = TagLib.getMetadata(fd.detachFd())
                     val propertyMap = metadata?.propertyMap
-                    val lyricsField = propertyMap?.get("LYRICS")?.firstOrNull()
-                        ?: propertyMap?.get("UNSYNCEDLYRICS")?.firstOrNull()
-
-                    if (!lyricsField.isNullOrBlank()) {
-                        val parsedLyrics = LyricsUtils.parseLyrics(lyricsField)
-                        if (parsedLyrics.isValid()) {
-                            Log.d(TAG, "===== FOUND EMBEDDED LYRICS =====")
-                            parsedLyrics.copy(areFromRemote = false)
-                        } else {
-                            null
-                        }
+                    val parsedLyrics = parseBestEmbeddedLyricsField(propertyMap)
+
+                    if (parsedLyrics != null) {
+                        Log.d(TAG, "===== FOUND EMBEDDED LYRICS =====")
+                        parsedLyrics
                     } else {
                         null
                     }

app/src/main/java/com/theveloper/pixelplay/data/repository/LyricsRepositoryImpl.kt

@@ -688,8 +688,15 @@ class MusicRepositoryImpl @Inject constructor(
                             applyDirectoryFilter = applyDirectoryFilter
                         )
                     } else {
-                        musicDao.getSongsByGenre(
+                        // getSongsByGenreContaining uses a LIKE query so that a song stored as
+                        // "Rock, Pop" is returned when browsing either "Rock" or "Pop".
+                        musicDao.getSongsByGenreContaining(
                             genreName = genreName,
+                            genrePrefix = "$genreName,%",          // "Rock,..." / "Rock, ..."
+                            genreSuffixWithSpace = "%, $genreName", // "..., Rock"
+                            genreSuffix = "%,$genreName",          // "...,Rock"
+                            genreMiddleWithSpace = "%, $genreName,%", // "..., Rock,..."
+                            genreMiddle = "%,$genreName,%",        // "...,Rock,..."
                             allowedParentDirs = allowedParentDirs,
                             applyDirectoryFilter = applyDirectoryFilter
                         )
@@ -877,6 +884,7 @@ class MusicRepositoryImpl @Inject constructor(
                     ) { genreNames, hasUnknown ->
                         val knownGenres = genreNames
                             .asSequence()
+                            .flatMap { raw -> raw.split(",") } // split "Rock, Pop" → ["Rock", "Pop"]
                             .map { it.trim() }
                             .filter { it.isNotBlank() }
                             .map { buildGenre(it) }

app/src/main/java/com/theveloper/pixelplay/data/repository/MusicRepositoryImpl.kt

@@ -921,9 +921,6 @@ class MusicService : MediaLibraryService() {
             }
         }
         return hasWearHints
-        // If hints identify a Wear/remote controller and it's not our app package,
-        // reject to avoid the default Wear system media player hijacking the session.
-        return true
     }
 
     private fun createSleepTimerPendingIntent(): PendingIntent {
@@ -2332,7 +2329,9 @@ class MusicService : MediaLibraryService() {
     }
 
     private fun readBytesCapped(input: java.io.InputStream, maxBytes: Int): ByteArray? {
-        val output = ByteArrayOutputStream()
+        // Pre-size to 4× the read-buffer to reduce reallocation churn on typical album art
+        // (50–300 KB). Still far below the maxBytes cap enforced in the loop below.
+        val output = ByteArrayOutputStream(DEFAULT_STREAM_BUFFER_SIZE * 4)
         val buffer = ByteArray(DEFAULT_STREAM_BUFFER_SIZE)
         var totalRead = 0
         while (true) {
@@ -2846,13 +2845,6 @@ class MusicService : MediaLibraryService() {
         }
     }
 
-    /**
-     * Bridges a suspend block into a [ListenableFuture] for Media3 callback methods.
-     */
-    /**
-     * Bridges a suspend block into a [ListenableFuture] for Media3 callback methods.
-     */
-
     /**
      * Bridges a suspend block into a [ListenableFuture] for Media3 callback methods.
      */