Plug-in do Android para Gradle 9.0.1 (janeiro de 2026)

O Plug-in do Android para Gradle 9.0 é uma versão principal que traz mudanças na API e no comportamento.

Para atualizar para o Plug-in do Android para Gradle 9.0.1, use o Assistente de upgrade do Plug-in do Android para Gradle. O assistente de upgrade do AGP ajuda a preservar os comportamentos atuais ao fazer upgrade do projeto, sempre que apropriado. Assim, você pode fazer upgrade do projeto para usar o AGP 9.0, mesmo que não esteja pronto para adotar todos os novos padrões do AGP 9.0.

Também há duas habilidades de agente disponíveis para facilitar o processo de upgrade. Para um app que não é KMP, tente a habilidade de upgrade do AGP 9 no repositório de habilidades do Android. Para um app KMP, teste a habilidade de upgrade do AGP 9 (link em inglês) da JetBrains. Para mais informações sobre o uso de habilidades no Android Studio, consulte Estender o Modo Agente com habilidades.

Compatibilidade

O nível máximo da API com suporte do Plug-in do Android para Gradle 9.0 é o 36.1. Confira outras informações de compatibilidade:

Versão mínima Versão padrão Observações
Gradle 9.1.0 9.1.0 Para saber mais, consulte Como atualizar o Gradle.
Ferramentas de build do SDK 36.0.0 36.0.0 Instale ou configure as ferramentas de build do SDK.
NDK N/A 28.2.13676358 Instale ou configure uma versão diferente do NDK.
JDK 17 17 Para saber mais, consulte Como configurar a versão do JDK.
Plug-in do Kotlin para Gradle (KGP) 2.2.10 2.2.10 Para saber mais, consulte Dependência de tempo de execução no plug-in do Gradle para Kotlin.

As classes DSL android agora implementam apenas as novas interfaces públicas.

Nos últimos anos, introduzimos novas interfaces para nossa DSL e API para controlar melhor quais APIs são públicas. As versões 7.x e 8.x do AGP ainda usavam os tipos de DSL antigos (por exemplo, BaseExtension), que também implementavam as novas interfaces públicas, para manter a compatibilidade enquanto o trabalho nas interfaces avançava.

O AGP 9.0 usa exclusivamente nossas novas interfaces de DSL, e as implementações mudaram para novos tipos que estão totalmente ocultos. Isso também remove o acesso à API de variante antiga e descontinuada.

Para atualizar para o AGP 9.0, talvez seja necessário fazer o seguinte:

  • Verifique se o projeto é compatível com o Kotlin integrado:o plug-in org.jetbrains.kotlin.android não é compatível com a nova DSL.

  • Mudar projetos KMP para o Plug-in do Android para Gradle para KMP:o uso do plug-in org.jetbrains.kotlin.multiplatform no mesmo subprojeto do Gradle que os plug-ins com.android.library e com.android.application não é compatível com a nova DSL.

  • Atualize os arquivos de build:embora a mudança de interfaces tenha como objetivo manter a DSL o mais semelhante possível, pode haver algumas pequenas mudanças.

  • Atualize sua lógica de build personalizada para referenciar a nova DSL e API:substitua todas as referências à DSL interna pelas interfaces de DSL públicas. Na maioria dos casos, essa será uma substituição direta. Substitua qualquer uso de applicationVariants e APIs semelhantes pela nova API androidComponents. Isso pode ser mais complexo, já que a API androidComponents foi projetada para ser mais estável e manter os plug-ins compatíveis por mais tempo. Confira nossas instruções do Gradle para ver exemplos.

  • Atualize os plug-ins de terceiros:alguns plug-ins de terceiros ainda podem depender de interfaces ou APIs que não estão mais expostas. Migre para versões desses plug-ins que sejam compatíveis com o AGP 9.0.

A mudança para as novas interfaces de DSL impede que plug-ins e scripts de build do Gradle usem várias APIs descontinuadas, incluindo:

API descontinuada no bloco android Função Substituição
applicationVariants,
libraryVariants,
testVariants e
unitTestVariants 		Pontos de extensão para plug-ins adicionarem novas funcionalidades ao AGP. Substitua-o pela API androidComponents.onVariants, por exemplo: 
androidComponents {
    onVariants() { variant ->
        variant.signingConfig
            .enableV1Signing.set(false)
    }
}
 Talvez não haja uma substituição direta para todas as APIs anteriores. Registre um problema se houver um caso de uso que não seja coberto pelas novas APIs de variantes.
variantFilter Permite que as variantes selecionadas sejam desativadas. Substitua-a pela API androidComponents.beforeVariants, por exemplo: 
androidComponents {
    beforeVariants(
        selector()
            .withBuildType("debug")
            .withFlavor("color", "blue")
    ) { variantBuilder ->
        variantBuilder.enable = false
    }
  }
deviceProvider e
testServer 		Registro de ambientes de teste personalizados para executar testes em dispositivos Android e emuladores. Mude para dispositivos gerenciados pelo Gradle.
sdkDirectory,
ndkDirectory,
bootClasspath,
adbExecutable e
adbExe 		Usar vários componentes do SDK do Android para tarefas personalizadas. Mude para androidComponents.sdkComponents.
registerArtifactType,
registerBuildTypeSourceProvider,
registerProductFlavorSourceProvider,
registerJavaArtifact,
registerMultiFlavorSourceProvider e
wrapJavaSourceSet		 Funcionalidade obsoleta relacionada principalmente ao processamento de fontes geradas no Android Studio, que parou de funcionar no AGP 7.2.0. Não há uma substituição direta para essas APIs.
dexOptions Configurações obsoletas relacionadas à ferramenta dx, que foi substituída por d8. Nenhuma das configurações tem efeito desde o Plug-in do Android para Gradle 7.0. Não há substituição direta.
generatePureSplits Gere divisões de configuração para apps instantâneos. A capacidade de enviar divisões de configuração agora está integrada aos Android App Bundles.
aidlPackagedList Arquivos AIDL para empacotar no AAR para expor como API para bibliotecas e apps que dependem dessa biblioteca. Isso ainda é exposto em LibraryExtension, mas não nos outros tipos de extensão.

Se você atualizar para o AGP 9.0 e receber a seguinte mensagem de erro, isso significa que seu projeto ainda está referenciando alguns dos tipos antigos:

java.lang.ClassCastException: class com.android.build.gradle.internal.dsl.ApplicationExtensionImpl$AgpDecorated_Decorated
cannot be cast to class com.android.build.gradle.BaseExtension

Se você tiver problemas com plug-ins de terceiros incompatíveis, poderá desativar e recuperar as implementações antigas da DSL, bem como a API de variante antiga. Ao fazer isso, as novas interfaces também ficam disponíveis, e você ainda pode atualizar sua própria lógica de build para a nova API. Para recusar, inclua esta linha no arquivo gradle.properties:

android.newDsl=false

Como alternativa, para uma migração mais gradual, o AGP 9.4 permite que você desative módulos individuais. Para saber como fazer isso, consulte Desativação do módulo da API Variant.

As classes anteriores foram marcadas como descontinuadas no AGP 9.0. Isso significa que os projetos que desativarem a flag newDsl vão receber avisos de descontinuação, inclusive no próprio bloco android.

Também é possível começar a fazer upgrade para as novas APIs antes de fazer upgrade para o AGP 9.0. As novas interfaces estão presentes em muitas versões do AGP, então é possível ter uma combinação de novas e antigas. A documentação de referência da API AGP mostra a superfície da API para cada versão do AGP e quando cada classe, método e campo foi adicionado.

Estamos entrando em contato com os autores de plug-ins usados com frequência para ajudá-los a adaptar e lançar plug-ins totalmente compatíveis com os novos modos. Além disso, vamos continuar aprimorando o Assistente de upgrade do AGP no Android Studio para orientar você durante a migração.

Se você perceber que a nova DSL ou a API Variant não têm recursos ou funcionalidades, registre um problema assim que possível.

Kotlin integrado

O Plug-in do Android para Gradle 9.0 introduz suporte integrado ao Kotlin e o ativa por padrão. Isso significa que não é mais necessário aplicar o plug-in org.jetbrains.kotlin.android (ou kotlin-android) nos arquivos de build para compilar arquivos de origem do Kotlin. Isso simplifica a integração do Kotlin com o AGP, evita o uso de APIs descontinuadas e melhora o desempenho em alguns casos.

Portanto, ao fazer upgrade do projeto para o AGP 9.0, você também precisa migrar para o Kotlin integrado ou desativar.

Também é possível desativar seletivamente o suporte integrado ao Kotlin para subprojetos do Gradle que não têm fontes do Kotlin.

Dependência de tempo de execução para o plug-in do Gradle para Kotlin

Para oferecer suporte integrado ao Kotlin, o Plug-in do Android para Gradle 9.0 agora tem uma dependência de tempo de execução para o plug-in do Gradle do Kotlin (KGP) 2.2.10. Isso significa que você não precisa mais declarar uma versão do KGP. Se você usar uma versão anterior à 2.2.10, o Gradle vai fazer upgrade automático do KGP para a versão 2.2.10. Da mesma forma, se você usar uma versão do KSP anterior à 2.2.10-2.0.2, o AGP vai fazer upgrade dela para a 2.2.10-2.0.2 para corresponder à versão do KGP.

Fazer upgrade para uma versão mais recente do KGP

Para usar uma versão mais recente do KGP ou do KSP, adicione o seguinte ao arquivo de build de nível superior:

buildscript {
    dependencies {
        // For KGP
        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:KGP_VERSION")

        // For KSP
        classpath("com.google.devtools.ksp:symbol-processing-gradle-plugin:KSP_VERSION")
    }
}

Fazer downgrade para uma versão anterior do KGP

Só é possível fazer downgrade da versão do KGP se você desativou o Kotlin integrado. Isso ocorre porque o AGP 9.0 ativa o Kotlin integrado por padrão, e o Kotlin integrado requer o KGP 2.2.10 ou mais recente.

Para usar uma versão anterior do KGP ou do KSP, declare essa versão no arquivo de build de nível superior usando uma declaração de versão estrita:

buildscript {
    dependencies {
        // For KGP
        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin") {
            version { strictly("KGP_VERSION") }
        }

        // For KSP
        classpath("com.google.devtools.ksp:symbol-processing-gradle-plugin") {
            version { strictly("KSP_VERSION") }
        }
    }
}

A versão mínima do KGP para downgrade é a 2.0.0.

Suporte do IDE para preparação de teste

O AGP 9.0 oferece suporte completo ao ambiente de desenvolvimento integrado do Android Studio para preparações de teste.

Plug-in de biblioteca combinada

O plug-in de biblioteca combinada (pré-lançamento) permite publicar várias bibliotecas como um único AAR de biblioteca do Android. Isso pode facilitar para os usuários dependerem dos artefatos publicados.

Para saber como começar, consulte Publicar várias bibliotecas do Android como uma só com a biblioteca combinada.

Mudanças de comportamento

O Plug-in do Android para Gradle 9.0 tem os seguintes novos comportamentos:

Comportamento Recomendação
O Plug-in do Android para Gradle 9.0 usa a versão r28c do NDK por padrão. Considere especificar explicitamente a versão do NDK que você quer usar.
Por padrão, o Plug-in do Android para Gradle 9.0 exige que os consumidores de uma biblioteca usem a mesma versão do SDK de compilação ou uma mais recente. Use o mesmo SDK de compilação ou um mais recente ao consumir uma biblioteca. Se isso não for possível ou se você quiser dar mais tempo para os consumidores de uma biblioteca que você publica, defina AarMetadata.minCompileSdk explicitamente.

O AGP 9.0 inclui atualizações nos padrões das seguintes propriedades do Gradle. Isso permite que você preserve o comportamento do AGP 8.13 ao fazer upgrade:

Propriedade Função Mudança do AGP 8.13 para o AGP 9.0 Recomendação
android.newDsl Use as novas interfaces DSL sem expor as implementações legadas do bloco android.
Isso também significa que a API de variante legada, como android.applicationVariants, não está mais acessível. 		false → true Para desativar, defina android.newDsl=false.
Quando todos os plug-ins e a lógica de build usados pelo projeto forem compatíveis, remova a desativação.
android.builtInKotlin Ativa o Kotlin integrado. false → true Migre para o Kotlin integrado, se possível, ou desative.
android.uniquePackageNames Garante que cada biblioteca tenha um nome de pacote diferente. false → true Especifique nomes de pacotes exclusivos para todas as bibliotecas do seu projeto. Se isso não for possível, desative essa flag durante a migração.
android.useAndroidx Use as dependências androidx por padrão. false → true Adote as dependências androidx.
android.default.androidx.test.runner Execute testes no dispositivo com a classe androidx.test.runner.AndroidJUnitRunner por padrão, substituindo o padrão da classe descontinuada InstrumentationTestRunner por 
android {
  defaultConfig {
    testInstrumentationRunner = "..."
  }
}
 		false → true Adote AndroidJUnitRunner ou especifique explicitamente seu testInstrumentationRunner personalizado.
android.dependency.useConstraints Controla o uso de restrições de dependência entre configurações.
O padrão no AGP 9.0 é false, que usa apenas restrições em testes de dispositivos de aplicativos (AndroidTest). Definir como true vai reverter para o comportamento da versão 8.13. 		true → false Não use restrições de dependência em todos os lugares, a menos que seja necessário. Aceitar o novo padrão dessa flag também ativa otimizações no processo de importação do projeto, o que reduz o tempo de importação para builds com muitos subprojetos de biblioteca do Android.
android.enableAppCompileTimeRClass Compilar o código em aplicativos em uma classe R não final, alinhando a compilação do aplicativo com a da biblioteca.
Isso melhora a incrementalidade e abre caminho para futuras otimizações de desempenho no fluxo de processamento de recursos. 		false → true Muitos projetos podem simplesmente adotar o novo comportamento sem mudanças na origem. Se os campos da classe R forem usados em qualquer lugar que exija uma constante, como casos de switch, refatore para usar instruções if encadeadas.
android.sdk.defaultTargetSdkToCompileSdkIfUnset Usa a versão do SDK de compilação como o valor padrão para a versão do SDK de destino em apps e testes.
Antes dessa mudança, a versão do SDK de destino era definida como padrão para a versão mínima do SDK. 		false → true Especifique explicitamente a versão do SDK de destino para apps e testes.
android.onlyEnableUnitTestForTheTestedBuildType Cria apenas componentes de teste de unidade para o tipo de build testado.
No projeto padrão, isso resulta em um único teste de unidade para depuração, em que o comportamento anterior era executar testes de unidade para depuração ou lançamento. 		false → true Se o projeto não exigir que os testes sejam executados para depuração e lançamento, não será necessário fazer mudanças.
android.proguard.failOnMissingFiles Falha no build com um erro se algum dos arquivos de manutenção especificados na DSL do AGP não existir no disco. Antes dessa mudança, erros de digitação em nomes de arquivos faziam com que os arquivos fossem ignorados silenciosamente. false → true Remova todas as declarações inválidas de arquivos do ProGuard
android.r8.optimizedResourceShrinking Permite que o R8 mantenha menos recursos do Android ao considerar classes e recursos do Android juntos. false → true Se as regras de manutenção do seu projeto já estiverem completas, nenhuma mudança será necessária.
android.r8.strictFullModeForKeepRules Permite que o R8 mantenha menos ao não manter implicitamente o construtor padrão quando uma classe é mantida. Ou seja, -keep class A não implica mais -keep class A { <init>(); }
 false → true Se as regras de manutenção do seu projeto já estiverem completas, nenhuma mudança será necessária.

Substitua -keep class A por -keep class A { <init>(); } nas regras de manutenção do projeto em todos os casos em que você precisar que o construtor padrão seja mantido.
android.defaults.buildfeatures.resvalues Ativa resValues em todos os subprojetos true → false Ative o resValues apenas nos subprojetos que precisam dele, definindo o seguinte nos arquivos de build do Gradle desses projetos: 
android {
  buildFeatures {
    resValues = true
  }
}
android.defaults.buildfeatures.shaders Ativa a compilação de sombreador em todos os subprojetos. true → false Ative a compilação de sombreadores apenas nos subprojetos que contêm sombreadores a serem compilados, definindo o seguinte nos arquivos de build do Gradle desses projetos: 
android {
  buildFeatures {
    shaders = true
  }
}
android.r8.proguardAndroidTxt.disallowed No AGP 9.0, o getDefaultProguardFile() só vai oferecer suporte a proguard-android-optimize.txt, em vez de proguard-android.txt. Isso evita o uso acidental da flag ­dontoptimize, que está incluída em proguard-android.txt. false → true É possível especificar explicitamente ­dontoptimize em um proguardFile personalizado se você quiser evitar a otimização, além de usar proguard-android-optimize.txt. Se possível, remova a flag ­dontoptimize desse arquivo, porque ela reduz os benefícios de otimização do R8. Caso contrário, desative a opção definindo android.r8.globalOptionsInConsumerRules.disallowed=false.
android.r8.globalOptionsInConsumerRules.disallowed A partir do AGP 9.0, a publicação de bibliotecas e módulos de recursos do Android vai falhar se os arquivos de retenção do consumidor tiverem configurações problemáticas do Proguard. Os arquivos de manutenção do consumidor que incluem opções globais, como ­dontoptimize ou ­dontobfuscate, só podem ser usados em módulos de aplicativos e podem reduzir os benefícios de otimização para os usuários da biblioteca. A compilação do módulo do app Android vai ignorar silenciosamente essas opções globais se elas estiverem incorporadas em uma dependência pré-compilada (JAR ou AAR). Para saber quando isso ocorre, verifique o arquivo configuration.txt (geralmente em um caminho como <app_module>/build/outputs/mapping/<build_variant>/configuration.txt) para encontrar comentários como: # REMOVED CONSUMER RULE: ­dontoptimize false → true As bibliotecas publicadas precisam remover todas as regras incompatíveis. As bibliotecas internas precisam mover as regras incompatíveis, mas necessárias, para um proguardFile em um módulo de app. Para desativar, defina android.r8.globalOptionsInConsumerRules.disallowed=false. Quando todos os arquivos do Keep do consumidor forem compatíveis, remova a desativação.
android.sourceset.disallowProvider Não permite a transmissão de provedores para fontes geradas usando a DSL AndroidSourceSet. false → true Use a API Sources em androidComponents para registrar as fontes geradas.
android.custom.shader.path.required Exige que o caminho do compilador de sombreador seja definido explicitamente em local.properties se a compilação de sombreador estiver ativada. false → true Adicione glslc.dir=/path/to/shader-tools ao local.properties do seu projeto.

Recursos removidos

O Plug-in do Android para Gradle 9.0 remove as seguintes funcionalidades:

  • Suporte a apps para Wear OS incorporados
    O AGP 9.0 remove o suporte à incorporação de apps para Wear OS, que não é mais compatível com o Google Play. Isso inclui remover as configurações wearApp e a DSL AndroidSourceSet.wearAppConfigurationName. Consulte Distribuir para Wear OS para saber como publicar seu app para Wear OS.
  • Tarefa de relatório androidDependencies e sourceSets
  • Suporte a APKs divididos por densidade
    O AGP 9.0 remove o suporte à criação de APKs divididos com base na densidade da tela. A funcionalidade e as APIs relacionadas foram removidas. Para dividir APKs com base na densidade da tela usando o AGP 9.0 ou mais recente, use pacotes de app.

DSL alterada

O Plug-in do Android para Gradle 9.0 tem as seguintes mudanças interruptivas na DSL:

  • A parametrização de CommonExtension foi removida.

    Por si só, essa é apenas uma alteração interruptiva no nível da origem para ajudar a evitar futuras alterações interruptivas no nível da origem, mas também significa que os métodos de bloqueio precisam ser movidos de CommonExtension para ApplicationExtension, LibraryExtension, DynamicFeatureExtension e TestExtension.

    Ao fazer upgrade do projeto para o AGP 9.0, refatore o código do plug-in do Gradle que usa esses parâmetros ou os métodos de bloco. Por exemplo, o plug-in a seguir é atualizado para remover o parâmetro de tipo e não depender dos métodos de bloqueio removidos:

    AGP 8.13

    val commonExtension: CommonExtension<*, *, *, *, *, *> =
        extensions.getByType(CommonExtension::class)
commonExtension.apply {
    defaultConfig {
        minSdk {
            version = release(28)
        }
    }
}

    AGP 9.0

    val commonExtension: CommonExtension =
        extensions.getByType(CommonExtension::class)
commonExtension.apply {
    defaultConfig.apply {
        minSdk {
            version = release(28)
        }
    }
}

    Para plug-ins que segmentam uma variedade de versões do AGP, o uso direto do getter é compatível com versões do AGP anteriores à 9.0.

DSL removida

O Plug-in do Android para Gradle 9.0 remove:

APIs removidas

O Plug-in do Android para Gradle 9.0 remove:

Propriedades do Gradle removidas

As propriedades do Gradle a seguir foram adicionadas inicialmente como formas de desativar globalmente recursos que eram ativados por padrão.

Esses recursos foram desativados por padrão desde o AGP 8.0 ou versões anteriores. Ative esses recursos apenas nos subprojetos que os usam para um build mais eficiente.

Propriedade Função Substituição
android.defaults.buildfeatures.aidl Ativa a compilação da AIDL em todos os subprojetos. Ative a compilação da AIDL apenas nos subprojetos em que há origens da AIDL definindo a seguinte propriedade nos arquivos de build do Gradle desses projetos: 
android {
  buildFeatures {
    aidl = true
  }
}
 no arquivo de build do Gradle de cada subprojeto que contém origens AIDL.
android.defaults.buildfeatures.renderscript Ativa a compilação do RenderScript em todos os subprojetos. Ative a compilação do RenderScript apenas nos subprojetos em que há origens do RenderScript definindo a seguinte propriedade nos arquivos de build do Gradle desses projetos: 
android {
  buildFeatures {
    renderScript = true
  }
}

Propriedades do Gradle aplicadas

O AGP 9.0 vai gerar um erro se você definir as seguintes propriedades do Gradle.

O Assistente de upgrade do Plug-in do Android para Gradle não vai fazer upgrade de projetos para o AGP 9.0 que usam essas propriedades.

Propriedade Função
android.r8.integratedResourceShrinking A redução de recursos agora é sempre executada como parte do R8. A implementação anterior foi removida.
android.enableNewResourceShrinker.preciseShrinking A redução de recursos agora sempre usa a redução precisa de recursos, o que permite remover mais itens.

Mudanças no R8

As mudanças do R8 a seguir estão incluídas no AGP 9.0.0.

Nova opção de configuração -processkotlinnullchecks

Adicionamos a nova opção -processkotlinnullchecks do R8 para configurar o R8 para processar verificações de nulo do Kotlin. A opção usa um argumento obrigatório que precisa ser um dos três valores a seguir: keep, remove_message e remove. A opção processa as seguintes verificações de nulo adicionadas pelo compilador do Kotlin:

class kotlin.jvm.internal.Intrinsics {
  void checkNotNull(java.lang.Object);
  void checkNotNull(java.lang.Object, java.lang.String);
  void checkExpressionValueIsNotNull(
      java.lang.Object, java.lang.String);
  void checkNotNullExpressionValue(
      java.lang.Object, java.lang.String);
  void checkReturnedValueIsNotNull(
      java.lang.Object, java.lang.String);
  void checkReturnedValueIsNotNull(
      java.lang.Object, java.lang.String, java.lang.String);
  void checkFieldIsNotNull(java.lang.Object, java.lang.String);
  void checkFieldIsNotNull(
      java.lang.Object, java.lang.String, java.lang.String);
  void checkParameterIsNotNull(java.lang.Object, java.lang.String);
  void checkNotNullParameter(java.lang.Object, java.lang.String);
}

Os valores das opções, ordenados do mais fraco ao mais forte, têm o seguinte efeito:

  • keep não muda as verificações.
  • remove_message reescreve cada chamada de método de verificação para uma chamada para getClass() no primeiro argumento da chamada (mantendo a verificação de nulo, mas sem nenhuma mensagem).
  • remove remove completamente as verificações.

Por padrão, o R8 usa remove_message. Qualquer especificação de -processkotlinnullchecks vai substituir isso. Se especificado várias vezes, o valor mais forte será usado.

Parar de propagar informações de manutenção para métodos complementares

Quando as regras de manutenção correspondem a métodos de interface sujeitos à simplificação, o R8 transferia internamente os bits de não permitir otimização e não permitir redução para os métodos complementares sintetizados.

A partir do AGP 9.0, as regras de manutenção não se aplicam mais a métodos complementares. Isso é consistente com o fato de que as regras de manutenção não são relevantes para outros campos/métodos/classes sintetizados pelo compilador.

Ao transferir os bits disallow optimization e disallow shrinking para os métodos complementares, o seguinte caso de uso era aceito:

  1. Compile uma biblioteca com métodos de interface default/static/private para DEX com minSdk < 24 e regras que mantêm os métodos de interface.
  2. Compile um app com a biblioteca no caminho de classe e -applymapping.
  3. Mescle o app e a biblioteca.

Isso só funciona com -applymapping, porque o bit disallow obfuscation não é transferido para os métodos complementares. Ou seja, as classes complementares geradas na etapa 1 teriam nomes de métodos ofuscados.

A partir de agora, esse caso de uso não é mais compatível com minSdk < 24. A solução alternativa é fazer o seguinte:

  1. Remova o sugar sintático da biblioteca com métodos de interface default/static/private para arquivos de classe com minSdk < 24.
  2. Compile o artefato simplificado usando o R8 e as regras que mantêm os métodos de interface nas classes complementares.
  3. Compile o app com a biblioteca no classpath.
  4. Mescle o app e o artefato simplificado.

Outro efeito colateral disso é que não é mais possível manter os atributos de classe interna e de método de fechamento para classes anônimas e locais dentro de métodos complementares de interface.

Mudar o arquivo de origem emitido padrão para r8-map-id-<MAP_ID>

Essa mudança está no AGP a partir da versão 8.12.0.

O atributo de arquivo de origem emitido padrão para uma classe muda de SourceFile para r8-map-id-<MAP_ID> quando o retracing é necessário (ou seja, quando a ofuscação ou a otimização está ativada).

Dado um stack trace ofuscado, o novo atributo de arquivo de origem possibilita extrair o ID do arquivo de mapeamento necessário para o retrace, que pode ser usado para oferecer suporte ao retrace automatizado de stack traces no Logcat.

Se um atributo de arquivo de origem personalizado for usado (-renamesourcefileattribute), ele vai continuar tendo precedência.

No modo de compatibilidade do ProGuard (quando gradle.properties contém android.enableR8.fullMode=false), a emissão de um atributo de arquivo de origem de r8-map-id-<MAP_ID> só entra em vigor se o atributo SourceFile não for mantido. Os apps que usam o modo de compatibilidade do ProGuard e querem incluir o ID do arquivo de mapeamento nos stack traces precisam remover -keepattributes SourceFile (ou migrar para o modo completo do R8).

O ID do mapa usado em r8-map-id-<MAP_ID> é o hash completo do mapa, e não um prefixo de 7 caracteres do hash do mapa que foi usado anteriormente.

Ativar o uso de nomes sintéticos minimizados na simplificação de sintaxe do L8

O nome das classes sintéticas geradas pelo D8 normalmente contém a substring $$ExternalSynthetic, que informa que se trata de uma classe sintética gerada pelo D8. Além disso, o nome do sintético também codifica o tipo sintético (por exemplo, Backport, Lambda). Isso tem um impacto negativo no tamanho do DEX resultante, já que os nomes de classe ocupam mais espaço no pool de strings.

O AGP 9.0 configura o L8 (simplificação da biblioteca principal) para que o arquivo DEX que contém todas as classes j$ use um novo formato de nome de classe reduzido para classes sintéticas. O novo nome da classe usa um ID numérico (por exemplo, $1).

Remover suporte para -addconfigurationdebugging

O AGP 9.0 remove o suporte para -addconfigurationdebugging. O compilador agora informa um aviso se a flag for usada.

Remoção do suporte para gerar regras L8 do D8/R8

Essa mudança é relevante apenas para desenvolvedores que usam a linha de comando ou as APIs do D8/R8 diretamente.

O R8 9.0 remove o suporte à geração de regras de manutenção para o L8 do D8 e do R8. Em vez disso, use TraceReferences para essa finalidade.

Mais especificamente, os métodos D8Command.builder.setDesugaredLibraryKeepRuleConsumer e R8Command.Builder.setDesugaredLibraryKeepRuleConsumer foram removidos, e o suporte para --desugared-lib-pg-conf-output foi removido das opções de linha de comando do D8 e do R8.

Problemas corrigidos

Plug-in do Android para Gradle 9.0.0

Problemas corrigidos
Plug-in do Android para Gradle
Solicitação de recurso: injetar a versão ideal do AGP como uma propriedade.
Estabilização de SingleArtifact.VERSION_CONTROL_INFO_FILE
A saída do logcat do androidTest connectedCheck está corrompida
O suporte integrado ao Kotlin no AGP não deve ser sincronizado com os conjuntos de origem do Kotlin
missingDimensionStrategy prefere uma variação que corresponda ao próprio nome, mesmo de uma dimensão não relacionada
O suporte integrado ao Kotlin no AGP não deve ser sincronizado com os conjuntos de origem do Kotlin
O AGP 9.0.0-rc01 não resolve bibliotecas Kotlin usando a função kotlin()
O Built-in-kotlin não publica a restrição de dependência kotlin-stdlib no pom do Maven
Adição de um caso de teste para divergência entre compileSdk e targetSdk.
O valor resConfigs vazio leva a um erro obscuro do aapt.
O projeto Java puro tem dependência da stdlib do Kotlin.
Remover propriedades descontinuadas do KotlinMultiplatformAndroidCompilationBuilder no AGP 9.0
`com.android.tools.build:gradle:9.0.0-alpha05` precisa ter uma dependência de API no KGP e na gradle-api
Renomear o plug-in do Gradle com.android.experimental.built-in-kotlin
AGP9: `variant.sources.kotlin!!.addGeneratedSourceDirectory()` não está funcionando
As verificações de metadados do AAR no SDK de compilação usam a DSL antiga.
Remoção da propriedade descontinuada "com.android.build.api.dsl.ManagedDevices.devices"
O suporte integrado ao Kotlin no AGP não deve ser sincronizado com os conjuntos de origem do Kotlin
Falha na publicação da biblioteca do Android se o arquivo de retenção do consumidor tiver -dontobfuscate
Não há opções para imprimir o mapeamento de recursos otimizados
Chamar finalizeDsl após essa fase vai gerar um erro.
O AGP inicializa a configuração do Jetifier mesmo quando ele está desativado
O Kotlin integrado não adiciona kotlinStdlib como uma dependência de tempo de compilação quando `kotlin.stdlib.default.dependency` é verdadeiro para arquivos de módulo e pom
A nova DSL de otimização não cria configuration.txt por padrão
O AGP 8.13.0 não consegue verificar o gráfico de navegação em um módulo
O AGP usa a API Gradle descontinuada: notação de várias strings
Aviso para usuários que tentam usar a biblioteca multidex legada com minSdkVersion >=21
Um build falha se houver tarefas de geração de código
Com `android.builtInKotlin=false`, `android.newDsl=false` e `android.enableLegacyVariantApi=false`, o uso do plug-in `kotlin-android` vai falhar com a mensagem "A API 'applicationVariants' está obsoleta".
O Kotlin integrado não consegue resolver o kotlin-stdlib sem versão quando kotlin.stdlib.default.dependency=false
O DexData abre um arquivo sem fechar, impedindo a limpeza
O AndroidSourceDirectorySet não deve mais estender o PatternFilterable no AGP 9.0
Erro de fixture de teste em módulos somente de teste
Erro incorreto ao usar receptores de contexto em fixtures de teste
Erros incorretos do ambiente de desenvolvimento integrado para o código Kotlin em testFixtures
O plug-in "legacy-kapt" ignora o processamento de anotações, ao contrário do "kotlin-kapt"
compileSdkSpec.minorApiLevel não está funcionando com SettingsExtension
[biblioteca combinada — pública] A biblioteca combinada gerada não inclui fontes
extractNativeLibs e useEmbeddedDex não podem vir do manifesto
Avisos do R8 no AGP 9.0.0-alpha09
Remoção do AndroidSourceSet.jni descontinuado no AGP 9.0
Remoção de Installation.installOptions() no AGP 9.0
Remoção de BuildType.isRenderscriptDebuggable no AGP 9.0.
Remover android.defaults.buildfeatures.renderscript
`com.android.kotlin.multiplatform.library` falha com dispositivos gerenciados pelo Gradle
Remoção das flags padrão gradle.properties de `android.defaults.buildfeatures.aidl`
Falha no build quando o arquivo ProGuard não existe.
remover flags padrão de buildconfig em gradle.properties
Mudança do valor padrão de targetSdk do app para ser baseado em compileSdk em vez de minSdk.
Quando "isIncludeAndroidResources" está ativado, "process{Variant}UnitTestManifest" não consegue mesclar os usos de tools:overrideLibrary no AGP 8.12.0
O AGP está causando avisos de descontinuação no Gradle para tarefas de teste da JVM
DependencyReportTask é incompatível com o cache de configuração.
Mudar a versão padrão de origem/destino do Java de Java 8 para Java 11 no AGP 9.0
Mudança do padrão de android.useAndroidX para verdadeiro.
Melhoria na exceção ao aplicar o plug-in kapt com o Kotlin integrado.
android.proguard.failOnMissingFiles não está funcionando para consumerProguardFiles
Atualização da dependência do plug-in do Gradle do Kotlin para 2.2.10
Criar KotlinJvmAndroidCompilation usando a API KGP
Modo de API explícito do Kotlin aplicado a origens de teste
Lint
AGP 8.11.0: a tarefa lintAnalyzeRelease falha ao aplicar arquivos .gradle.kts com apply(from = "...")
A verificação SdkIntAtLeast do Lint não verifica se o valor anotado está correto.
O Kotlin integrado não adiciona .kotlin_module ao META-INF
O caminho de classe do lint contém classes duplicadas em versões diferentes
A solução alternativa para substituir recursos particulares não está funcionando (tools:override = "true")
Bug: a remoção de recursos não utilizados não remove as traduções deles nem pergunta sobre isso
O lint estava gerando o aviso "Não foi possível limpar os caches do K2".
O lint estava gerando o aviso "Não foi possível limpar os caches do K2".
Integração com o Lint
Ausências no cache do AndroidLintAnalysisTask em diferentes fornecedores ou versões secundárias do JDK devido a diferenças em systemPropertyInputs.javaVersion
O Lint usa automaticamente o SDK mais recente instalado, apesar do compileSdk, não se registra como entrada de tarefa e interrompe o armazenamento em cache
Redutor (R8)
A redução de recursos otimizada do R8 falha silenciosamente se IDs de recursos finais são usados