fix: album art on Wear OS

Media Session items now contain a smaller 512x512 artwork bitmap that Wear OS can read

Author: banksio

app/src/main/AndroidManifest.xml

@@ -164,7 +164,7 @@
             android:name=".logic.GramophoneAlbumArtProvider"
             android:authorities="${applicationId}.albumart"
             android:exported="true"
-            android:permission="com.google.android.finsky.permission.GEARHEAD_SERVICE" />
+            android:grantUriPermissions="true" />
 
         <receiver android:name=".ui.LyricWidgetProvider"
             android:exported="false">

app/src/main/java/org/akanework/gramophone/logic/GramophonePlaybackService.kt

@@ -59,6 +59,8 @@ import androidx.media3.common.Rating
 import androidx.media3.common.Timeline
 import androidx.media3.common.TrackSelectionParameters
 import androidx.media3.common.Tracks
+import coil3.size.Precision
+import org.akanework.gramophone.BuildConfig
 import androidx.media3.common.util.BitmapLoader
 import androidx.media3.common.util.Log
 import androidx.media3.common.util.Util.isBitmapFactorySupportedMimeType
@@ -160,12 +162,50 @@ class GramophonePlaybackService : MediaLibraryService(), MediaSessionService.Lis
     val endedWorkaroundPlayer
         get() = internalPlayer
 
+    private val pendingArtworkUrls = hashSetOf<String>()
+
     private lateinit var libraryTreeLoader: LibraryTreeLoader
 
     private fun convertMetadata(metadata: MediaMetadata): MediaMetadata {
         val artworkUri = metadata.artworkUri ?: return metadata
         val providerUri = ArtResolver.toProviderUri(artworkUri) ?: return metadata
-        return metadata.buildUpon().setArtworkUri(providerUri).build()
+        val builder = metadata.buildUpon().setArtworkUri(providerUri)
+        if (metadata.artworkData != null) {
+            return builder.build()
+        }
+        val cacheKey = artworkUri.toString()
+        synchronized(pendingArtworkUrls) {
+            if (pendingArtworkUrls.add(cacheKey)) {
+                scope.launch {
+                    try {
+                        val bytes = ArtUtils.getResizedArtworkBytes(this@GramophonePlaybackService, artworkUri, 512)
+                        if (bytes != null) {
+                            withContext(Dispatchers.Main) {
+                                val player = endedWorkaroundPlayer
+                                if (player != null) {
+                                    val currentIndex = player.currentMediaItemIndex
+                                    val currentItem = player.getCurrentMediaItem()
+                                    if (currentItem != null && currentItem.mediaMetadata.artworkUri == artworkUri) {
+                                        val newMetadata = currentItem.mediaMetadata.buildUpon()
+                                            .setArtworkData(bytes, MediaMetadata.PICTURE_TYPE_FRONT_COVER)
+                                            .build()
+                                        val newMediaItem = currentItem.buildUpon()
+                                            .setMediaMetadata(newMetadata)
+                                            .build()
+                                        player.replaceMediaItem(currentIndex, newMediaItem)
+                                    }
+                                }
+                            }
+                        }
+                    } finally {
+                        synchronized(pendingArtworkUrls) {
+                            pendingArtworkUrls.remove(cacheKey)
+                        }
+                    }
+                }
+            }
+        }
+        return builder.build()
     }
 
     private fun convertItem(item: MediaItem): MediaItem {
@@ -458,6 +498,7 @@ class GramophonePlaybackService : MediaLibraryService(), MediaSessionService.Lis
                                     .data(data)
                                     .memoryCacheKey(data.hashCode().toString())
                                     .size(limit, limit)
+                                    .precision(Precision.INEXACT)
                                     .allowHardware(false)
                                     .target(
                                         onStart = { _ ->
@@ -495,6 +536,7 @@ class GramophonePlaybackService : MediaLibraryService(), MediaSessionService.Lis
                                 ImageRequest.Builder(this@GramophonePlaybackService)
                                     .data(uri)
                                     .size(limit, limit)
+                                    .precision(Precision.INEXACT)
                                     .allowHardware(false)
                                     .target(
                                         onStart = { _ ->

app/src/main/java/org/akanework/gramophone/logic/utils/ArtResolver.kt

@@ -92,7 +92,7 @@ object ArtResolver {
                 val filePath = path
                 val parentPath = File(filePath).parent
                 val list = mutableListOf<ArtResource>()
-                if (size <= 320) {
+                if (size <= 512) {
                     list.add(ArtResource.SongMediaStore(songId))
                     if (parentPath != null) {
                         list.add(ArtResource.AlbumFolder(parentPath))
@@ -110,7 +110,7 @@ object ArtResolver {
             scheme == "gramophoneAlbumCover" -> {
                 val albumId = authority
                 val folderPath = path
-                if (size <= 320) {
+                if (size <= 512) {
                     listOf(
                         ArtResource.AlbumMediaStore(albumId),
                         ArtResource.AlbumFolder(folderPath)
@@ -135,7 +135,7 @@ object ArtResolver {
                 if (type == "song") {
                     val parentPath = File(realPath).parent
                     val list = mutableListOf<ArtResource>()
-                    if (size <= 320) {
+                    if (size <= 512) {
                         list.add(ArtResource.SongMediaStore(id))
                         if (parentPath != null) {
                             list.add(ArtResource.AlbumFolder(parentPath))
@@ -150,7 +150,7 @@ object ArtResolver {
                     }
                     list
                 } else if (type == "album") {
-                    if (size <= 320) {
+                    if (size <= 512) {
                         listOf(
                             ArtResource.AlbumMediaStore(id),
                             ArtResource.AlbumFolder(realPath)
@@ -316,6 +316,9 @@ object ArtResolver {
      * Returns `null` if the URI is not one of the custom schemes.
      */
     fun toProviderUri(uri: Uri): Uri? {
+        if (uri.scheme == ContentResolver.SCHEME_CONTENT && uri.authority == PROVIDER_AUTHORITY) {
+            return uri
+        }
         return when (uri.scheme) {
             "gramophoneSongCover" -> buildProviderUri(
                 "song",

app/src/main/java/org/akanework/gramophone/logic/utils/CoilArtPipeline.kt

@@ -29,7 +29,7 @@ object CoilArtPipeline {
     fun Options.getArtworkBucketSize(): Int {
         val requestWidth = size.width.pxOrElse { 0 }
         val requestHeight = size.height.pxOrElse { 0 }
-        return if (requestWidth > 320 || requestHeight > 320) 1024 else 320
+        return if (requestWidth > 512 || requestHeight > 512) 1024 else 512
     }
 
     class ResolutionInterceptor : Interceptor {
@@ -52,7 +52,7 @@ object CoilArtPipeline {
                 val size = chain.size
                 val androidUri = coilUri.toAndroidUri()
                 // Use a stable bucket size for candidates to improve cache hits
-                val bucketSize = if (size.width.pxOrElse { 0 } > 320 || size.height.pxOrElse { 0 } > 320) 1024 else 320
+                val bucketSize = if (size.width.pxOrElse { 0 } > 512 || size.height.pxOrElse { 0 } > 512) 1024 else 512
                 val candidates = ArtResolver.getResolutionList(androidUri, bucketSize)
 
                 Log.d(TAG, "Intercepted artwork URI: $coilUri, bucketSize: $bucketSize, candidates: ${candidates.size}")