Implement SharedArtworkContentProvider to centralize and secure album art distribution across the system and external controllers.

### Core Architecture & Artwork Sharing
- **SharedArtworkContentProvider**: Introduced a new `ContentProvider` to handle artwork requests via a dedicated authority (`${applicationId}.artwork`). It provides read-only access to cached album art files, improving compatibility with system media style and external metadata consumers.
- **URI Resolution**: Implemented robust URI building and parsing logic within the provider to handle song-specific artwork requests, including support for cache-busting tokens (`?t=`).
- **Manifest Integration**: Registered the new provider with `exported="true"` to allow cross-process artwork access.

### Artwork Utilities & Optimization
- **LocalArtworkUri Enhancements**:
    - Added support for detecting and parsing "volatile" artwork URIs (legacy cache files and new shared content URIs).
    - Implemented `extractCacheBustToken` to preserve timestamp metadata during URI transformations.
    - Refactored `resolveSongArtworkUri` to handle transitions from volatile or legacy URIs to stable internal URI formats.
- **MediaItem Mapping**: Updated `MediaItemBuilder` to use `SharedArtworkContentProvider` URIs when exposing artwork to external controllers, ensuring consistent image loading in notifications and Wear OS.

### Reliability & Testing
- **Unit Tests**:
    - Added `SharedArtworkContentProviderTest` to verify authority building, URI construction, and song ID parsing.
    - Expanded `LocalArtworkUriTest` to cover legacy cache filename parsing, shared URI resolution, and cache-bust token extraction.
- **Security**: Restricted `SharedArtworkContentProvider` to read-only mode and validated file paths to ensure only legitimate cached artwork is served.

Author: theovilardo

app/src/main/AndroidManifest.xml

@@ -242,6 +242,10 @@
                 android:name="android.support.FILE_PROVIDER_PATHS"
                 android:resource="@xml/file_paths" />
         </provider>
+        <provider
+            android:name=".data.provider.SharedArtworkContentProvider"
+            android:authorities="${applicationId}.artwork"
+            android:exported="true" />
 
         <!-- Wear OS Data Layer: receives playback/volume commands from the watch -->
         <service

app/src/main/java/com/theveloper/pixelplay/data/provider/SharedArtworkContentProvider.kt

@@ -0,0 +1,139 @@
+package com.theveloper.pixelplay.data.provider
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.content.Context
+import android.content.res.AssetFileDescriptor
+import android.database.Cursor
+import android.net.Uri
+import android.os.ParcelFileDescriptor
+import com.theveloper.pixelplay.utils.AlbumArtUtils
+import java.io.File
+import java.io.FileNotFoundException
+
+class SharedArtworkContentProvider : ContentProvider() {
+
+    override fun onCreate(): Boolean = true
+
+    override fun query(
+        uri: Uri,
+        projection: Array<out String>?,
+        selection: String?,
+        selectionArgs: Array<out String>?,
+        sortOrder: String?
+    ): Cursor? = null
+
+    override fun getType(uri: Uri): String? {
+        val appContext = context?.applicationContext ?: return null
+        return if (parseSongId(uri, appContext.packageName) != null) {
+            DEFAULT_CONTENT_TYPE
+        } else {
+            null
+        }
+    }
+
+    override fun insert(uri: Uri, values: ContentValues?): Uri? = null
+
+    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int = 0
+
+    override fun update(
+        uri: Uri,
+        values: ContentValues?,
+        selection: String?,
+        selectionArgs: Array<out String>?
+    ): Int = 0
+
+    override fun openFile(uri: Uri, mode: String): ParcelFileDescriptor {
+        if (mode != "r") {
+            throw FileNotFoundException("Shared artwork provider is read-only")
+        }
+
+        val file = resolveArtworkFile(uri)
+            ?: throw FileNotFoundException("No artwork found for uri=$uri")
+
+        return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
+    }
+
+    override fun openAssetFile(uri: Uri, mode: String): AssetFileDescriptor {
+        val fileDescriptor = openFile(uri, mode)
+        return AssetFileDescriptor(fileDescriptor, 0, AssetFileDescriptor.UNKNOWN_LENGTH)
+    }
+
+    private fun resolveArtworkFile(uri: Uri): File? {
+        val appContext = context?.applicationContext ?: return null
+        val songId = parseSongId(uri, appContext.packageName) ?: return null
+        return AlbumArtUtils.ensureAlbumArtCachedFile(
+            appContext = appContext,
+            songId = songId
+        )?.takeIf { it.exists() && it.isFile && it.canRead() }
+    }
+
+    companion object {
+        private const val AUTHORITY_SUFFIX = ".artwork"
+        private const val PATH_SONG = "song"
+        private const val DEFAULT_CONTENT_TYPE = "image/jpeg"
+
+        fun authority(packageName: String): String = packageName + AUTHORITY_SUFFIX
+
+        fun buildSongUri(
+            context: Context,
+            songId: Long,
+            cacheBustToken: String? = null
+        ): Uri = buildSongUri(context.packageName, songId, cacheBustToken)
+
+        internal fun buildSongUri(
+            packageName: String,
+            songId: Long,
+            cacheBustToken: String? = null
+        ): Uri {
+            return Uri.parse(buildSongUriString(packageName, songId, cacheBustToken))
+        }
+
+        internal fun buildSongUriString(
+            packageName: String,
+            songId: Long,
+            cacheBustToken: String? = null
+        ): String {
+            val baseUri = "content://${authority(packageName)}/$PATH_SONG/$songId"
+            return cacheBustToken
+                ?.takeIf { it.isNotBlank() }
+                ?.let { "$baseUri?t=$it" }
+                ?: baseUri
+        }
+
+        internal fun parseSongId(uri: Uri, packageName: String? = null): Long? {
+            return parseSongId(uri.toString(), packageName)
+        }
+
+        internal fun parseSongId(uriString: String, packageName: String? = null): Long? {
+            val expectedPrefix = packageName
+                ?.let(::authority)
+                ?.let { "content://$it/$PATH_SONG/" }
+
+            if (expectedPrefix != null && !uriString.startsWith(expectedPrefix)) {
+                return null
+            }
+
+            val basePrefix = expectedPrefix ?: run {
+                val authoritySeparator = "://"
+                val schemeSplit = uriString.indexOf(authoritySeparator)
+                if (schemeSplit < 0) return null
+                val pathStart = uriString.indexOf('/', schemeSplit + authoritySeparator.length)
+                if (pathStart < 0) return null
+                val pathPrefix = uriString.substring(pathStart)
+                if (!pathPrefix.startsWith("/$PATH_SONG/")) return null
+                uriString.substring(0, pathStart) + "/$PATH_SONG/"
+            }
+
+            val songIdSegment = uriString
+                .removePrefix(basePrefix)
+                .substringBefore('?')
+                .substringBefore('/')
+
+            if (songIdSegment.isBlank()) {
+                return null
+            }
+            return songIdSegment.toLongOrNull()
+        }
+    }
+}

app/src/main/java/com/theveloper/pixelplay/utils/LocalArtworkUri.kt

@@ -5,6 +5,7 @@ import android.net.Uri
 object LocalArtworkUri {
     const val SCHEME = "pixelplay_local_art"
     private const val HOST_SONG = "song"
+    private const val CACHE_BUST_QUERY = "t"
 
     fun buildSongUri(songId: Long): String = "$SCHEME://$HOST_SONG/$songId"
     fun buildSongUriWithTimestamp(songId: Long): String = buildSongUri(songId) + "?t=${System.currentTimeMillis()}"
@@ -28,13 +29,49 @@ object LocalArtworkUri {
     fun looksLikeVolatileArtworkUri(uriString: String?): Boolean {
         if (uriString.isNullOrBlank()) return false
         val normalized = uriString.lowercase()
-        return normalized.contains("song_art_") &&
+        val isLegacyCachedFileUri = normalized.contains("song_art_") &&
             (
                 normalized.startsWith("content://") ||
                     normalized.startsWith("file://") ||
                     normalized.startsWith("/") ||
                     normalized.contains(".provider/")
                 )
+        val isSharedArtworkUri = normalized.startsWith("content://") &&
+            normalized.contains(".artwork/song/")
+        return isLegacyCachedFileUri || isSharedArtworkUri
+    }
+
+    fun parseSongIdFromVolatileArtworkUri(uriString: String?): Long? {
+        if (uriString.isNullOrBlank()) return null
+        if (!looksLikeVolatileArtworkUri(uriString)) return null
+
+        val fileName = uriString.substringAfterLast('/').substringBefore('?')
+        if (!fileName.startsWith("song_art_")) {
+            return null
+        }
+
+        return fileName
+            .removePrefix("song_art_")
+            .substringBefore('_')
+            .substringBefore('.')
+            .toLongOrNull()
+    }
+
+    fun extractCacheBustToken(uriString: String?): String? {
+        if (uriString.isNullOrBlank()) return null
+        val query = uriString.substringAfter('?', "")
+        if (query.isBlank()) return null
+        return query
+            .split('&')
+            .asSequence()
+            .mapNotNull { entry ->
+                val separatorIndex = entry.indexOf('=')
+                if (separatorIndex <= 0) return@mapNotNull null
+                val key = entry.substring(0, separatorIndex)
+                if (key != CACHE_BUST_QUERY) return@mapNotNull null
+                entry.substring(separatorIndex + 1).takeIf { it.isNotBlank() }
+            }
+            .firstOrNull()
     }
 
     fun isLikelyLocalMedia(contentUriString: String): Boolean {
@@ -56,14 +93,16 @@ object LocalArtworkUri {
             return normalizedStoredUri
         }
 
-        return if (isLocalArtworkUri(normalizedStoredUri) || looksLikeVolatileArtworkUri(normalizedStoredUri)) {
-            if (normalizedStoredUri.contains("?t=")) {
-                normalizedStoredUri
-            } else {
-                buildSongUri(songId)
+        return when {
+            isLocalArtworkUri(normalizedStoredUri) -> {
+                if (normalizedStoredUri.contains("?t=")) {
+                    normalizedStoredUri
+                } else {
+                    buildSongUri(songId)
+                }
             }
-        } else {
-            normalizedStoredUri
+            looksLikeVolatileArtworkUri(normalizedStoredUri) -> buildSongUri(songId)
+            else -> normalizedStoredUri
         }
     }
 }

app/src/main/java/com/theveloper/pixelplay/utils/MediaItemBuilder.kt

@@ -7,6 +7,7 @@ import androidx.core.content.FileProvider
 import androidx.core.net.toUri
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MediaMetadata
+import com.theveloper.pixelplay.data.provider.SharedArtworkContentProvider
 import com.theveloper.pixelplay.data.model.Song
 import java.io.File
 
@@ -209,7 +210,19 @@ object MediaItemBuilder {
     fun externalControllerArtworkUri(context: Context, rawArtworkUri: String?): Uri? {
         if (LocalArtworkUri.isLocalArtworkUri(rawArtworkUri)) {
             val songId = rawArtworkUri?.let(LocalArtworkUri::parseSongId) ?: return null
-            return AlbumArtUtils.getCachedAlbumArtUri(context.applicationContext, songId)
+            return SharedArtworkContentProvider.buildSongUri(
+                context = context.applicationContext,
+                songId = songId,
+                cacheBustToken = LocalArtworkUri.extractCacheBustToken(rawArtworkUri)
+            )
+        }
+
+        LocalArtworkUri.parseSongIdFromVolatileArtworkUri(rawArtworkUri)?.let { songId ->
+            return SharedArtworkContentProvider.buildSongUri(
+                context = context.applicationContext,
+                songId = songId,
+                cacheBustToken = LocalArtworkUri.extractCacheBustToken(rawArtworkUri)
+            )
         }
 
         val normalizedUri = normalizeArtworkUri(rawArtworkUri, SUPPORTED_EXTERNAL_ARTWORK_SCHEMES)

app/src/test/java/com/theveloper/pixelplay/data/provider/SharedArtworkContentProviderTest.kt

@@ -0,0 +1,49 @@
+package com.theveloper.pixelplay.data.provider
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class SharedArtworkContentProviderTest {
+
+    @Test
+    fun buildSongUri_usesDedicatedArtworkAuthority() {
+        val uri = SharedArtworkContentProvider.buildSongUriString(
+            packageName = "com.theveloper.pixelplay",
+            songId = 42L
+        )
+
+        assertThat(uri).isEqualTo("content://com.theveloper.pixelplay.artwork/song/42")
+    }
+
+    @Test
+    fun buildSongUri_preservesCacheBustToken() {
+        val uri = SharedArtworkContentProvider.buildSongUriString(
+            packageName = "com.theveloper.pixelplay",
+            songId = 42L,
+            cacheBustToken = "1234"
+        )
+
+        assertThat(uri)
+            .isEqualTo("content://com.theveloper.pixelplay.artwork/song/42?t=1234")
+    }
+
+    @Test
+    fun parseSongId_rejectsOtherAuthorities() {
+        val songId = SharedArtworkContentProvider.parseSongId(
+            uriString = "content://example.com.artwork/song/42",
+            packageName = "com.theveloper.pixelplay"
+        )
+
+        assertThat(songId).isNull()
+    }
+
+    @Test
+    fun parseSongId_readsSharedArtworkSongUri() {
+        val songId = SharedArtworkContentProvider.parseSongId(
+            uriString = "content://com.theveloper.pixelplay.artwork/song/42",
+            packageName = "com.theveloper.pixelplay"
+        )
+
+        assertThat(songId).isEqualTo(42L)
+    }
+}

app/src/test/java/com/theveloper/pixelplay/utils/LocalArtworkUriTest.kt

@@ -16,6 +16,17 @@ class LocalArtworkUriTest {
         assertThat(resolved).isEqualTo(LocalArtworkUri.buildSongUri(42L))
     }
 
+    @Test
+    fun resolveSongArtworkUri_convertsSharedArtworkUriToStableUri() {
+        val resolved = LocalArtworkUri.resolveSongArtworkUri(
+            storedUri = "content://com.theveloper.pixelplay.artwork/song/42?t=1234",
+            songId = 42L,
+            contentUriString = "content://media/external/audio/media/42"
+        )
+
+        assertThat(resolved).isEqualTo(LocalArtworkUri.buildSongUri(42L))
+    }
+
     @Test
     fun resolveSongArtworkUri_keepsRemoteArtworkUriUntouched() {
         val resolved = LocalArtworkUri.resolveSongArtworkUri(
@@ -44,4 +55,22 @@ class LocalArtworkUriTest {
 
         assertThat(songId).isEqualTo(99L)
     }
+
+    @Test
+    fun parseSongIdFromVolatileArtworkUri_readsLegacyCacheFileName() {
+        val songId = LocalArtworkUri.parseSongIdFromVolatileArtworkUri(
+            "content://com.theveloper.pixelplay.provider/cache/song_art_77_v2.jpg"
+        )
+
+        assertThat(songId).isEqualTo(77L)
+    }
+
+    @Test
+    fun extractCacheBustToken_readsTimestampQuery() {
+        val cacheBustToken = LocalArtworkUri.extractCacheBustToken(
+            "pixelplay_local_art://song/99?t=456"
+        )
+
+        assertThat(cacheBustToken).isEqualTo("456")
+    }
 }