Exibir arte de mídia

A arte em itens de mídia precisa ser transmitida como um URI local usando ContentResolver.SCHEME_CONTENT ou ContentResolver.SCHEME_ANDROID_RESOURCE. Esse URI local precisa ser resolvido para um bitmap ou um drawable vetorial nos recursos do aplicativo. Para objetos MediaDescriptionCompat que representam itens na hierarquia de conteúdo, transmita o URI usando setIconUri.

Para objetos MediaMetadataCompat que representam o item em reprodução, use uma destas chaves para transmitir o URI com putString:

• MediaMetadataCompat.METADATA_KEY_DISPLAY_ICON_URI
• MediaMetadataCompat.METADATA_KEY_ART_URI
• MediaMetadataCompat.METADATA_KEY_ALBUM_ART_URI

Estas etapas descrevem como fazer o download da arte de um URI da Web e expô-la com um URI local. Para conferir um exemplo completo, consulte a implementação de openFile e os métodos próximos no app de exemplo Universal Android Music Player.

1. Crie um URI content:// correspondente ao URI da Web. O serviço de navegador de mídia e a sessão de mídia transmitem esse URI de conteúdo ao Android Auto e o Android Automotive OS (AAOS).

   Kotlin

   fun Uri.asAlbumArtContentURI(): Uri {
         return Uri.Builder()
           .scheme(ContentResolver.SCHEME_CONTENT)
           .authority(CONTENT_PROVIDER_AUTHORITY)
           .appendPath(this.getPath()) // Make sure you trust the URI
           .build()
     }
   

   Java

   public static Uri asAlbumArtContentURI(Uri webUri) {
         return new Uri.Builder()
           .scheme(ContentResolver.SCHEME_CONTENT)
           .authority(CONTENT_PROVIDER_AUTHORITY)
           .appendPath(webUri.getPath()) // Make sure you trust the URI!
           .build();
    }
   

2. Na sua implementação de ContentProvider.openFile, verifique se existe um arquivo para o URI correspondente. Caso contrário, faça o download e armazene o arquivo de imagem em cache. Este snippet de código usa o Glide.

   Kotlin

   override fun openFile(uri: Uri, mode: String): ParcelFileDescriptor? {
         val context = this.context ?: return null
         val file = File(context.cacheDir, uri.path)
         if (!file.exists()) {
           val remoteUri = Uri.Builder()
               .scheme("https")
               .authority("my-image-site")
               .appendPath(uri.path)
               .build()
           val cacheFile = Glide.with(context)
               .asFile()
               .load(remoteUri)
               .submit()
               .get(DOWNLOAD_TIMEOUT_SECONDS, TimeUnit.SECONDS)
   
           cacheFile.renameTo(file)
            file = cacheFile
         }
         return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
    }
   

   Java

   @Nullable
     @Override
     public ParcelFileDescriptor openFile(@NonNull Uri uri, @NonNull String mode)
           throws FileNotFoundException {
         Context context = this.getContext();
         File file = new File(context.getCacheDir(), uri.getPath());
         if (!file.exists()) {
           Uri remoteUri = new Uri.Builder()
               .scheme("https")
               .authority("my-image-site")
               .appendPath(uri.getPath())
               .build();
           File cacheFile = Glide.with(context)
               .asFile()
               .load(remoteUri)
               .submit()
               .get(DOWNLOAD_TIMEOUT_SECONDS, TimeUnit.SECONDS);
   
           cacheFile.renameTo(file);
           file = cacheFile;
         }
         return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
     }
   

Para detalhes sobre provedores de conteúdo, consulte Criar um provedor de conteúdo.

Observação: o URI de conteúdo precisa ser criado e enviado rapidamente ao Android Auto e ao AAOS, como demonstrado no exemplo anterior. Isso é válido mesmo quando o arquivo não é baixado. O Android Auto e o AAOS mostram uma interface de carregamento para as imagens enquanto aguardam a resposta do provedor de conteúdo. Otimize seu app para buscar imagens rapidamente e minimizar o tempo necessário para carregar a interface. Considere o pré-carregamento e o armazenamento em cache de imagens.