Converter JAR para AAR

Um projeto Android pode exigir um AAR quando uma biblioteca fornecida é distribuída como um JAR, mas também precisa de recursos Android, entradas de manifesto ou metadados de biblioteca. A conversão empacota as classes JVM existentes em um contêiner de biblioteca Android; ela não transforma automaticamente código Java para desktop em código compatível com Android.

O que é o formato JAR

Um JAR (Java ARchive) é um pacote baseado em ZIP que contém arquivos JVM .class, recursos, metadados e, opcionalmente, um manifesto que identifica uma classe principal executável. Bibliotecas Java e Kotlin, aplicativos para desktop, Maven, Gradle, IntelliJ IDEA e Android Studio usam arquivos JAR com frequência.

Um JAR pode ser usado diretamente por um projeto Android quando seu bytecode e suas dependências são compatíveis com Android. Ele não fornece inerentemente recursos Android, um manifesto de biblioteca Android, regras R8 para consumidores, bibliotecas nativas ou metadados de empacotamento específicos do Android.

O que é o formato AAR

Um AAR (Android ARchive) é o formato de arquivo de biblioteca do Android Gradle Plugin. Ele também é um arquivo ZIP, que normalmente contém classes.jar e AndroidManifest.xml, com res/, assets/, jni/, prefab/, lint.jar, proguard.txt e arquivos de símbolos de recursos opcionais.

Um AAR pode fornecer recursos Android, declarações de manifesto, bibliotecas nativas, regras de shrinker para consumidores e código de biblioteca compilado como um único artefato de biblioteca Android. O Gradle mescla esses componentes em um aplicativo. O arquivo não contém automaticamente dependências Maven externas; normalmente, elas são declaradas nos metadados de publicação ou fornecidas separadamente.

Como empacotar um JAR como AAR

Inspecione o JAR primeiro

Liste seu conteúdo com a ferramenta do JDK antes de empacotá-lo:

jar tf vendor.jar

Confirme se ele contém classes de biblioteca, e não um aplicativo para desktop, e verifique seu nível de bytecode Java. O compilador D8 do Android pode processar bytecode Java compatível, mas classes que chamam APIs exclusivas de desktop, como AWT, Swing ou módulos JDK indisponíveis, não se tornarão utilizáveis no Android apenas por meio do empacotamento.

Wrapper mínimo para uma biblioteca Java pura

Para um JAR que não precisa de código-fonte Android, recursos ou declarações de manifesto adicionais, crie um diretório AAR contendo o JAR com o nome obrigatório classes.jar e um manifesto:

mkdir aar-temp
cp vendor.jar aar-temp/classes.jar
printf '%s\n' '<manifest xmlns:android="http://schemas.android.com/apk/res/android" />' > aar-temp/AndroidManifest.xml
(cd aar-temp && zip -r ../vendor.aar classes.jar AndroidManifest.xml)

No Windows, o jar do JDK ou o 7-Zip pode criar o arquivo ZIP: adicione classes.jar e AndroidManifest.xml na raiz do arquivo e salve-o como vendor.aar. Não os coloque dentro de um diretório adicional.

Essa é uma operação de empacotamento, não uma compilação ou conversão de dependências. Se o JAR também precisar de recursos Android, adicione-os na raiz do AAR, em res/; adicione os recursos do aplicativo em assets/ e as declarações necessárias a AndroidManifest.xml.

Use um módulo de biblioteca Android para adições Android

1. No Android Studio, escolha File → New → New Module → Android Library e selecione um SDK mínimo apropriado.
2. Coloque o código-fonte Android, os recursos, os assets e as declarações de manifesto nos diretórios src/main do módulo.
3. Adicione o JAR original como uma dependência de tempo de compilação se o código do módulo fizer chamadas a ele:

dependencies {
    implementation files('libs/vendor.jar')
}

Para Kotlin DSL, use implementation(files("libs/vendor.jar")). A compilação do módulo com ./gradlew :mylibrary:assembleRelease cria um AAR em um caminho como mylibrary/build/outputs/aar/mylibrary-release.aar.

Uma compilação padrão de biblioteca Android geralmente não incorpora uma dependência JAR local no AAR resultante. A dependência permanece separada, portanto, um consumidor pode precisar do JAR original. Para distribuir um único arquivo, use o wrapper mínimo quando nenhum código Android compilado adicional for necessário, mescle o JAR em classes.jar com uma tarefa de empacotamento personalizada ou use um plugin Gradle fat-AAR mantido, após verificar sua compatibilidade com a versão do Android Gradle Plugin do projeto. Uma solução fat-AAR pode criar classes duplicadas e conflitos de dependências.

Verificações de compatibilidade e qualidade

Renomear vendor.jar para vendor.aar é inválido porque um AAR espera a biblioteca compilada em classes.jar, além de um manifesto Android. Verifique o arquivo com unzip -l vendor.aar ou 7-Zip.

Compatibilize o nível de bytecode da biblioteca com as configurações de compatibilidade Java e Kotlin da compilação Android. Verifique suas dependências transitivas, as permissões ou os componentes exigidos pelo manifesto, as bibliotecas nativas, as referências de recursos e as regras R8 para consumidores; um wrapper manual não pode gerar informações ausentes.

Teste o AAR em um aplicativo Android separado usando versões compatíveis do Android Gradle Plugin, do SDK de compilação e do SDK mínimo. Se a biblioteca contiver apenas classes Java compatíveis com Android e nenhum conteúdo específico do Android, distribuir o JAR original pode ser mais simples do que produzir um AAR.

Ferramentas online e para desktop

Não existe um conversor online geral e confiável de JAR para AAR, porque o resultado correto depende dos recursos Android, das declarações de manifesto, das dependências e da compatibilidade do bytecode. Evite enviar bibliotecas proprietárias para serviços de arquivos na Web. Use o Android Studio com o Android Gradle Plugin para compilações de módulos e o comando jar do JDK ou o 7-Zip para o empacotamento local e transparente de arquivos.