Adicionar dependências de compilação

O sistema de build do Gradle no Android Studio permite incluir binários externos ou outros módulos de biblioteca no build como dependências. As dependências podem estar localizadas na sua máquina ou em um repositório remoto. Todas as dependências transitivas declaradas também serão incluídas automaticamente. Esta página descreve como usar dependências com um projeto do Android, incluindo detalhes sobre comportamentos e configurações específicos do Plug-in do Android para Gradle (AGP, na sigla em inglês). Para um guia conceitual mais detalhado sobre as dependências do Gradle, consulte o Guia do Gradle para gerenciamento de dependências. No entanto, lembre-se de que o projeto do Android precisa usar apenas as configurações de dependência definidas nesta página.

Adicionar uma dependência de biblioteca ou plug-in

A melhor maneira de adicionar e gerenciar dependências de build é usar catálogos de versões, o método usado por novos projetos por padrão. Esta seção aborda os tipos mais comuns de configurações usadas para projetos Android. Consulte a documentação do Gradle para mais opções. Para conferir um exemplo de app que usa catálogos de versões, consulte Now in Android (em inglês). Se você já tiver dependências de build configuradas sem catálogos de versões e tiver um projeto com vários módulos, recomendamos migrar.

Para orientações sobre como adicionar e gerenciar dependências nativas (não comuns), consulte Dependências nativas.

No exemplo abaixo, adicionamos uma dependência binária remota (a biblioteca Jetpack Macrobenchmark), uma dependência de módulo de biblioteca local (myLibrary) e uma dependência de plug-in (o Plug-in do Android para Gradle) ao projeto. Confira as etapas gerais para adicionar essas dependências ao projeto:

1. Adicione um alias para a versão da dependência que você quer na seção [versions] do arquivo de catálogo de versões, chamado libs.versions.toml (no diretório gradle na visualização Project ou Gradle Scripts na visualização Android):

   [versions]
   agp = "8.3.0"
   androidx-macro-benchmark = "1.2.2"
   my-library = "1.4"
   
   [libraries]
   ...
   
   [plugins]
   ...
   

   Os alias podem incluir traços ou sublinhados. Esses aliases geram valores aninhados que podem ser referenciados em scripts de build. As referências começam com o nome do catálogo, a parte libs de libs.versions.toml. Ao usar um único catálogo de versões, recomendamos manter o valor padrão de "libs".

2. Adicione um alias para a dependência nas seções [libraries] (para binários remotos ou módulos de biblioteca locais) ou [plugins] (para plug-ins) do arquivo libs.versions.toml.

   [versions]
   ...
   
   [libraries]
   androidx-benchmark-macro = { group = "androidx.benchmark", name = "benchmark-macro-junit4", version.ref = "androidx-macro-benchmark" }
   my-library = { group = "com.myapplication", name = "mylibrary", version.ref = "my-library" }
   
   [plugins]
   androidApplication = { id = "com.android.application", version.ref = "agp" }
   

   Algumas bibliotecas estão disponíveis em uma lista de materiais (BOM) publicada que agrupa famílias de bibliotecas e as versões delas. É possível incluir uma BoM no catálogo de versões e nos arquivos de build e deixar que ela gerencie essas versões para você. Consulte Como usar a Lista de materiais para mais detalhes.

3. Adicione uma referência ao alias de dependência no script de build dos módulos que exigem a dependência. Converta os sublinhados e traços do alias em pontos ao fazer referência a ele em um script de build. Nosso script de build no nível do módulo ficaria assim:

   Kotlin

   plugins {
     alias(libs.plugins.androidApplication)
   }
   
   dependencies {
     implementation(libs.androidx.benchmark.macro)
     implementation(libs.my.library)
   }

   Groovy

   plugins {
     alias 'libs.plugins.androidApplication'
   }
   
   dependencies {
     implementation libs.androidx.benchmark.macro
     implementation libs.my.library
   }

   As referências de plug-in incluem plugins após o nome do catálogo, e as referências de versão incluem versions após o nome do catálogo. As referências de versão são incomuns. Consulte Dependências com os mesmos números de versão para conferir exemplos de referências de versão. As referências de biblioteca não incluem um qualificador libraries. Portanto, não é possível usar versions ou plugins no início de um alias de biblioteca.

Configurar dependências

Dentro do bloco dependencies, você pode declarar uma dependência de biblioteca usando uma das várias configurações de dependência diferentes (como implementation mostrado anteriormente). Cada configuração de dependência fornece ao Gradle instruções diferentes sobre como usar a dependência. A tabela a seguir descreve cada uma das configurações que podem ser usadas para uma dependência em um projeto do Android.

dependencies {
  // Executes lint checks from the ":checks" project at build time.
  lintChecks(project(":checks"))
  // Compiles lint checks from the ":checks-to-publish" into a
  // lint.jar file and publishes it to your Android library.
  lintPublish(project(":checks-to-publish"))
}

dependencies {
  // Executes lint checks from the ':checks' project at build time.
  lintChecks project(':checks')
  // Compiles lint checks from the ':checks-to-publish' into a
  // lint.jar file and publishes it to your Android library.
  lintPublish project(':checks-to-publish')
}

Configurar dependências para uma variante de build específica

Todas as configurações anteriores aplicam dependências a todas as variantes de build. Se você quiser declarar uma dependência apenas para um conjunto de origem de uma variante de build específica ou para um conjunto de origem de teste, use inicial maiúscula no nome da configuração e adicione o prefixo do nome da variante de build ou do conjunto de origem de teste.

Por exemplo, para adicionar uma dependência binária remota apenas à variação de produto "free" usando a configuração implementation, use este código:

dependencies {
    freeImplementation("com.google.firebase:firebase-ads:21.5.1")
}

dependencies {
    freeImplementation 'com.google.firebase:firebase-ads:21.5.1'
}

No entanto, se você quiser adicionar uma dependência para uma variante que combine uma variação de produto e um tipo de build, inicialize o nome da configuração:

// Initializes a placeholder for the freeDebugImplementation dependency configuration.
val freeDebugImplementation by configurations.creating

dependencies {
    freeDebugImplementation(project(":free-support"))
}

configurations {
    // Initializes a placeholder for the freeDebugImplementation dependency configuration.
    freeDebugImplementation {}
}

dependencies {
    freeDebugImplementation project(":free-support")
}

Para adicionar a dependência implementation para testes locais e instrumentados, o código é semelhante a:

dependencies {
    // Adds a remote binary dependency only for local tests.
    testImplementation("junit:junit:4.12")

    // Adds a remote binary dependency only for the instrumented test APK.
    androidTestImplementation("androidx.test.espresso:espresso-core:3.6.1")
}

dependencies {
    // Adds a remote binary dependency only for local tests.
    testImplementation 'junit:junit:4.12'

    // Adds a remote binary dependency only for the instrumented test APK.
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.6.1'
}

No entanto, algumas configurações não fazem sentido nessa situação. Por exemplo, como outros módulos não podem depender de androidTest, você receberá o seguinte aviso se usar a configuração androidTestApi:

WARNING: Configuration 'androidTestApi' is obsolete and has been replaced with
'androidTestImplementation'.

Ordem de dependências

A ordem em que as dependências são listadas indica a prioridade de cada uma: a primeira biblioteca tem maior prioridade que a segunda, a segunda tem maior prioridade que a terceira e assim por diante. Essa ordem é importante quando recursos são integrados ou elementos do manifesto são mesclados ao app a partir das bibliotecas.

Por exemplo, se o projeto declarar:

• A dependência de LIB_A e LIB_B (nessa ordem)
• E LIB_A depende de LIB_C e LIB_D (nessa ordem)
• E LIB_B também depende de LIB_C

A ordem de dependência combinada será a seguinte:

1. LIB_A
2. LIB_D
3. LIB_B
4. LIB_C

Isso garante que LIB_A e LIB_B possam substituir LIB_C. LIB_D mantém a prioridade maior que LIB_B porque LIB_A (que depende dele) tem prioridade maior que LIB_B.

Para saber mais sobre como manifestos de diferentes origens/dependências do projeto são integrados, consulte Integrar vários arquivos de manifesto.

Informações de dependência do Play Console

Ao criar o app, o AGP inclui metadados que descrevem as dependências de biblioteca compiladas no app. Durante o upload do app, o Play Console inspeciona esses metadados para enviar alertas sobre problemas conhecidos com SDKs e dependências que o app usa e, em alguns casos, fornece feedback útil para resolver esses problemas.

Os dados são compactados, criptografados por uma chave de assinatura do Google Play e armazenados no bloco de assinatura do app de lançamento. Recomendamos manter esse arquivo de dependências para uma experiência do usuário segura e positiva. Para desativar isso, inclua o bloco dependenciesInfo no arquivo build.gradle.kts do módulo.

android {
    dependenciesInfo {
        // Disables dependency metadata when building APKs.
        includeInApk = false
        // Disables dependency metadata when building Android App Bundles.
        includeInBundle = false
    }
}

Para mais informações sobre nossas políticas e possíveis problemas com dependências, consulte nossa página de suporte sobre como usar SDKs de terceiros no seu app.

Insights do SDK

O Android Studio mostra avisos de lint no arquivo de catálogo de versões e na caixa de diálogo Project Structure para SDKs públicos no SDK Index do Google Play quando os seguintes problemas se aplicam:

• Os SDKs são marcados como desatualizados pelos autores.
• Os SDKs violam as políticas do Google Play.

Os avisos são indicadores de que você precisa atualizar essas dependências, porque o uso de versões desatualizadas pode impedir que você publique no Google Play Console no futuro.

Adicionar dependências de build sem catálogos de versões

Recomendamos o uso de catálogos de versões para adicionar e gerenciar dependências, mas projetos simples podem não precisar deles. Confira um exemplo de um arquivo de build que não usa catálogos de versão:

plugins {
    id("com.android.application")
}

android { ... }

dependencies {
    // Dependency on a remote binary
    implementation("com.example.android:app-magic:12.3")
    // Dependency on a local library module
    implementation(project(":mylibrary"))
}

plugins {
    id 'com.android.application'
}

android { ... }

dependencies {
    // Dependency on a remote binary
    implementation 'com.example.android:app-magic:12.3'
    // Dependency on a local library module
    implementation project(':mylibrary')
}

Esse arquivo de build declara uma dependência da versão 12.3 da biblioteca "app-magic", dentro do grupo de namespace "com.example.android". A declaração de dependência binária remota é uma abreviação para o seguinte:

implementation(group = "com.example.android", name = "app-magic", version = "12.3")

implementation group: 'com.example.android', name: 'app-magic', version: '12.3'

O arquivo de build também declara uma dependência em um módulo de biblioteca do Android chamado "mylibrary". Esse nome precisa corresponder ao nome da biblioteca definido com um include: no arquivo settings.gradle.kts. Ao criar o app, o sistema de build compila o módulo de biblioteca e empacota o conteúdo compilado resultante no app.

O arquivo de build também declara uma dependência no Plug-in do Android para Gradle (com.application.android). Se você tiver vários módulos que usam o mesmo plug-in, só poderá ter uma única versão dele no caminho de classe do build em todos os módulos. Em vez de especificar a versão em cada um dos scripts de build do módulo, inclua a dependência do plug-in no script de build raiz com a versão e indique que ela não será aplicada. A adição de apply false informa ao Gradle a versão do plug-in, mas não o usa no build raiz. Normalmente, o script de build raiz está vazio, exceto por este bloco plugins.

plugins {
    id("org.jetbrains.kotlin.android") version "1.9.0" apply false
}

plugins {
    id ‘com.android.application’ version ‘8.3.0-rc02’ apply false
}

Se você tiver um projeto de módulo único, poderá especificar a versão explicitamente no script de build do módulo e deixar o script de build do projeto vazio:

plugins {
    id("com.android.application") version "8.3.0"
}

plugins {
    id 'com.android.application' version '8.3.0-rc02'
}