Contente

• Explorando os arquivos de construção do Gradle
• 1. settings.gradle
• 2. build.gradle (nível do projeto)
• 3. build.gradle (nível do módulo)
• Declarando as dependências do seu projeto: Bibliotecas locais
• Incluindo uma Dependência de Construção: Repositórios Remotos
• Conectando-se a um Repositório Remoto
• Declarando uma dependência remota
• Gerando vários APKs: como criar variantes de compilação
• Criando uma tarefa Gradle personalizada
• Construindo seu projeto com o wrapper Gradle
• Que outras tarefas Gradle estão disponíveis?
• Aproveitando melhor o Gradle: adicionando plugins
• O DSL Gradle Kotlin
• Empacotando

Em vez de Java, XML ou Kotlin, esses arquivos de compilação Gradle usam a linguagem específica de domínio (DSL) baseada em Groovy. Se você não estiver familiarizado com o Groovy, examinaremos linha por linha cada um desses arquivos de construção do Gradle. Assim, no final deste artigo, você ficará à vontade para ler e escrever código simples do Groovy.

O Gradle visa facilitar sua vida, fornecendo um conjunto de configurações padrão que você pode usar com a configuração manual mínima - quando estiver pronto para criar seu projeto, basta pressionar o botão "Executar" do Android Studio e o Gradle iniciará o processo de compilação para voce.

Apesar da abordagem de "convenção sobre configuração" de Gradle, se as configurações padrão não atenderem totalmente às suas necessidades, você poderá personalizar, configurar e estender o processo de compilação e até ajustar as configurações de Gradle para executar tarefas muito específicas.

Como os scripts Gradle estão contidos em seus próprios arquivos, você pode modificar o processo de criação do aplicativo a qualquer momento, sem precisar tocar no código-fonte do aplicativo. Neste tutorial, modificaremos o processo de criação usando sabores, variantes de criação e uma tarefa Gradle personalizada - tudo sem sempre tocando em nosso código de aplicativo.

Explorando os arquivos de construção do Gradle

Sempre que você cria um projeto, o Android Studio gera a mesma coleção de arquivos de construção do Gradle. Mesmo se você importar um projeto existente para o Android Studio, ele será ainda crie exatamente os mesmos arquivos Gradle e adicione-os ao seu projeto.

Para começar a entender melhor o Gradle e a sintaxe Groovy, vamos dar uma olhada, linha por linha, em cada um dos arquivos de criação do Android Gradle.

1. settings.gradle

O arquivo settings.gradle é onde você define todos os módulos do seu aplicativo por nome, usando a palavra-chave "include". Por exemplo, se você tivesse um projeto que consiste em um "aplicativo" e um "secondModule", seu arquivo settings.gradle seria algo parecido com isto:

include: app,: secondmodule rootProject.name = MyProject

Dependendo do tamanho do seu projeto, esse arquivo pode ser consideravelmente mais longo.

Durante o processo de compilação, Gradle examinará o conteúdo do arquivo settings.gradle do seu projeto e identificará todos os módulos que ele precisa incluir no processo de compilação.

2. build.gradle (nível do projeto)

O arquivo build.gradle no nível do projeto está localizado no diretório raiz do seu projeto e contém configurações que serão aplicadas a todos seus módulos (também chamados de "projetos" por Gradle).

Você deve usar esse arquivo para definir quaisquer plugins, repositórios, dependências e opções de configuração que se apliquem a todos os módulos do seu projeto Android. Observe que, se você definir qualquer tarefa Gradle no arquivo build.gradle no nível do projeto, ainda será possível substituir ou estender essas tarefas para módulos individuais, editando os respectivos no nível do módulo arquivo build.gradle.

Um arquivo build.gradle típico no nível do projeto terá a seguinte aparência:

buildscript {repositórios {google () jcenter ()} dependências {caminho de classe com.android.tools.build:gradle:3.5.0-alpha06 // NOTA: Não coloque suas dependências de aplicativos aqui; eles pertencem // no módulo individual build.gradle files}} todos os projetos {repositórios {google () jcenter ()}} limpos de tarefas (tipo: Delete) {delete rootProject.buildDir}

Esse arquivo build.gradle no nível do projeto é dividido nos seguintes blocos:

• Buildscript. Contém configurações necessárias para executar a compilação.
• Repositórios. Gradle é responsável por localizar as dependências do seu projeto e disponibilizá-las em sua compilação. No entanto, nem todas as dependências são do mesmo repositório, portanto, você precisará definir todos os repositórios que Gradle deve pesquisar, a fim de recuperar as dependências do seu projeto.
• Dependências. Esta seção contém as dependências do plug-in, que são baixadas e armazenadas no cache local. Você deve não defina quaisquer dependências do módulo dentro deste bloco.
• Todos os projetos. É aqui que você define os repositórios que devem estar disponíveis para todos dos módulos do seu projeto.

3. build.gradle (nível do módulo)

Este é o arquivo build.gradle no nível do módulo, presente em todos os módulos do projeto. Se o seu projeto Android consistir em vários módulos, ele também consistirá em vários arquivos build.gradle no nível do módulo.

Cada arquivo build.gradle no nível do módulo contém o nome do pacote, o nome da versão e o código da versão do projeto, além do SDK mínimo e de destino para esse módulo em particular.

Um arquivo build.gradle no nível do módulo também pode ter seu próprio conjunto exclusivo de instruções e dependências de construção. Por exemplo, se você estiver criando um aplicativo com um componente do Wear OS, seu projeto do Android Studio consistirá em um módulo separado de smartphone / tablet e um módulo do Wear - como eles estão segmentando dispositivos totalmente diferentes, esses módulos têm drasticamente diferentes dependências!

Um arquivo build.gradle básico no nível do módulo geralmente se parece com isso:

aplique o plugin: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.speechtotext" minSdkVersion 23 targetSdkVersion 28 versionCode 1 versionName "1.0" testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunnerText { getDefaultProguardFile (proguard-android-optimize.txt), proguard-rules.pro}}} dependências {implementação fileTree (dir: libs, include:) implementação androidx.appcompat: appcompat: 1.0.2 implementação androidx.constraintlayout: constraintlayout: 1.1. 3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1}

Vamos dar uma olhada em cada uma dessas seções:

• aplicar plugin. Esta é uma lista dos plugins necessários para construir este módulo. O plug-in com.android.application é necessário para configurar o processo de compilação específico do Android, portanto, ele é adicionado automaticamente.
• android. É aqui que você deve colocar todas as opções específicas da plataforma do módulo.
• compileSdkVersion. Este é o nível da API com o qual este módulo é compilado. Você não pode usar recursos de uma API maior que esse valor.
• buildToolsVersion. Isso indica a versão do compilador. No Gradle 3.0.0 e superior, buildToolsVersion é opcional; se você não especificar um valor buildToolsVersion, o Android Studio usará como padrão a versão mais recente das Ferramentas de compilação.
• defaultConfig. Ele contém opções que serão aplicadas a todas as versões de compilação do seu aplicativo, como as versões de depuração e lançamento.
• ID do aplicativo. Esse é o identificador exclusivo do seu aplicativo.
• minSdkVersion. Este parâmetro define o nível mais baixo da API suportado por este módulo.
• targetSdkVersion. Este é o nível máximo da API em que seu aplicativo foi testado. Idealmente, você deve testar seu aplicativo usando a API mais recente, o que significa que o valor targetSdkVersion sempre será igual ao valor compileSdkVersion.
• versionCode. Este é um valor numérico para a sua versão do aplicativo.
• versionName. Essa é uma sequência amigável, que representa a versão do seu aplicativo.
• buildTypes. Por padrão, o Android suporta dois tipos de compilação: depuração e lançamento. Você pode usar os blocos "debug" e "release" para especificar as configurações específicas do tipo do seu aplicativo.
• dependências. É aqui que você define as bibliotecas das quais este módulo depende.

Declarando as dependências do seu projeto: Bibliotecas locais

Você pode disponibilizar funcionalidades adicionais para seus projetos Android, adicionando uma ou mais dependências do projeto. Essas dependências podem ser locais ou podem ser armazenadas em um repositório remoto.

Para declarar uma dependência em um arquivo JAR local, você precisará adicioná-lo ao diretório "libs" do seu projeto.

Você pode modificar o arquivo build.gradle no nível do módulo para declarar uma dependência desse arquivo. Por exemplo, aqui estamos declarando uma dependência em um JAR da "minha biblioteca".

arquivos de implementação (libs / mylibrary.jar)

Como alternativa, se sua pasta "libs" continha vários JARs, seria mais fácil simplesmente declarar que seu projeto depende de todos os arquivos localizados na pasta "libs", por exemplo:

implementação fileTree (dir: libs, include:)

Incluindo uma Dependência de Construção: Repositórios Remotos

Se uma biblioteca estiver localizada em um repositório remoto, você precisará concluir as seguintes etapas:

• Defina o repositório em que esta dependência está localizada.
• Declare a dependência individual.

Conectando-se a um Repositório Remoto

A primeira etapa é informar a Gradle qual repositório (ou repositórios) ele precisa verificar, a fim de recuperar todas as dependências do seu projeto. Por exemplo:

repositórios {google () jcenter ()}}

Aqui, a linha “jcenter ()” garante que Gradle verifique o repositório do JCenter, que é um repositório público gratuito hospedado na bandeja.

Como alternativa, se você ou sua organização mantiver um repositório pessoal, adicione o URL desse repositório à sua declaração de dependência. Se o repositório estiver protegido por senha, você também precisará fornecer suas informações de login, por exemplo:

repositórios {mavenCentral () maven {// Configure o URL de destino // url "http://repo.mycompany.com/myprivaterepo"} maven {credenciais {nome do usuário nome de usuário minha senha do usuário senha myPassword} url "http://repo.mycompany.com / myprivaterepo "}

Se uma dependência estiver presente em vários repositórios, o Gradle selecionará a versão "melhor" dessa dependência, com base em fatores como a idade de cada repositório e a versão estática.

Declarando uma dependência remota

A próxima etapa é declarar a dependência no arquivo build.gradle no nível do módulo. Você adiciona essas informações ao bloco "dependências", usando qualquer um dos seguintes:

• Implementação. Essa é uma dependência normal que você precisa sempre que cria seu projeto. Uma dependência de "implementação" estará presente em todo todos suas construções.
• Implementação de Testes. Essa é uma dependência necessária para compilar a fonte de teste do seu aplicativo e executar testes baseados na JVM. Quando você marca uma dependência como "Implementação de Testes", Gradle saberá que não é necessário executar tarefas para essa dependência durante uma compilação normal, o que pode ajudar a reduzir o tempo de compilação.
• Implementação de teste do Android. Essa é uma dependência necessária ao executar testes em um dispositivo, por exemplo, a estrutura do Espresso é uma "implementação de teste para Android" comum.

Definimos uma dependência remota, usando uma das palavras-chave acima, seguidas pelos atributos de grupo, nome e versão da dependência, por exemplo:

dependências {implementação fileTree (dir: libs, include:) implementação androidx.appcompat: appcompat: 1.0.2 implementação androidx.constraintlayout: constraintlayout: 1.1.3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1}

Gerando vários APKs: como criar variantes de compilação

Às vezes, pode ser necessário criar várias versões do seu aplicativo. Por exemplo, você pode querer lançar uma versão gratuita e uma versão paga, que inclui alguns recursos adicionais.

Esta é uma tarefa de criação com a qual Gradle pode ajudá-lo. Vamos ver como você modifica o processo de criação para criar vários APKs a partir de um único projeto:

• Abra o arquivo strings.xml e exclua a string original do nome do aplicativo.
• Em seguida, defina os nomes de cada sabor do produto que você deseja criar; neste caso, estou usando:

Meu aplicativo gratuito Meu aplicativo pago

• Abra o arquivo AndroidManifest.xml e substitua android: label = ”@ string / app_name” por:

android: label = "$ {appName}"

• Abra o arquivo build.gradle no nível do módulo e adicione o seguinte ao bloco "android":

flavorDimensions "mode" productFlavors {free {dimension "mode" applicationIdSuffix ".free" manifestPlaceholders =} pago {dimension "mode" applicationIdSuffix ".paid" manifestPlaceholders =}}}

Vamos detalhar o que está acontecendo aqui:

• flavorDimensions. O plug-in Android cria variantes de construção combinando sabores de diferentes dimensões. Aqui, estamos criando uma dimensão de sabor que consiste nas versões "gratuita" e "paga" do nosso aplicativo. Com base no código acima, o Gradle gerará quatro variantes de compilação: paidDebug, paidRelease, freeDebug e freeRelease.
• productFlavors. Isso especifica uma lista de sabores e suas configurações, que no código acima são "pagas" e "gratuitas".
• Gratuito / pago. Estes são os nomes dos nossos dois sabores de produtos.
• Dimensão. Precisamos especificar um valor de parâmetro "dimensão"; neste caso, estou usando o "modo".
• applicationIdSuffix. Como queremos criar várias versões do nosso aplicativo, precisamos atribuir a cada APK um identificador exclusivo do aplicativo.
• manifestPlaceholders. Cada projeto possui um único arquivo de manifesto contendo informações importantes sobre a configuração do seu projeto. Ao criar várias variantes de compilação, normalmente você deseja modificar algumas dessas propriedades do manifesto no momento da compilação. Você pode usar os arquivos de construção Gradle para especificar entradas exclusivas do manifesto para cada variante de construção, que serão inseridas no manifesto no momento da construção. No código acima, estamos modificando o valor "appName", dependendo de a Gradle criar a versão gratuita ou paga do nosso aplicativo.

Criando uma tarefa Gradle personalizada

Às vezes, você pode precisar personalizar o processo de compilação, usando Gradle tarefas.

Uma tarefa é uma coleção nomeada de ações que o Gradle executará ao executar uma construção, por exemplo, gerar um Javadoc. O Gradle suporta muitas tarefas por padrão, mas você também pode criar tarefas personalizadas, que podem ser úteis se você tiver um conjunto muito específico de instruções de construção em mente.

Nesta seção, criaremos uma tarefa Gradle personalizada que irá percorrer todas as variantes de compilação do nosso projeto (paidDebug, paidRelease, freeDebug e freeRelease), criar data e hora e anexar essas informações a cada APK gerado.

Abra o arquivo build.gradle no nível do módulo e adicione o seguinte:

task addDateAndTime () {// Repete todas as variantes de criação de saída // android.applicationVariants.all {variant -> // Repete todos os arquivos APK // variant.outputs.all {output -> // Crie uma instância de a data e hora atuais, no formato especificado // def dateAndTime = new Date (). format ("aaaa-MM-dd: HH-mm") // Anexe essas informações ao nome do arquivo do APK // def fileName = variant. nome + "_" + dateAndTime + ".apk" output.outputFileName = fileName}}}

Em seguida, precisamos informar Gradle quando deve executar esta tarefa. Durante uma compilação, o Gradle identifica tudo o que precisa para baixar e todas as tarefas que precisa executar e as organiza em um Gráfico Acíclico Dirigido (DAG). Gradle executará todas essas tarefas, de acordo com a ordem definida em seu DAG.

Para meu aplicativo, vou usar o método "whenReady", que garante que nossa tarefa seja chamada assim que o DAG for preenchido e que Gradle esteja pronto para começar a executar suas tarefas.

Adicione o seguinte ao seu arquivo build.gradle no nível do módulo:

// Execute esta tarefa // gradle.taskGraph.whenReady {addDateAndTime}

Vamos colocar nossa tarefa personalizada e nosso código de variante de compilação para o teste, construindo este projeto usando um comando Gradle.

Construindo seu projeto com o wrapper Gradle

Você emite comandos Gradle usando o wrapper Gradle ("gradlew"). Esse script é a maneira preferida de iniciar uma compilação do Gradle, pois torna a execução da compilação independente da sua versão do Gradle. Essa separação pode ser útil se você estiver colaborando com outras pessoas que talvez não tenham necessariamente a mesma versão do Gradle instalada.

Ao emitir seus comandos do wrapper Gradle, você usará "gradlew" para sistemas operacionais semelhantes ao Unix, incluindo macOS, e "gradlew.bat" para Windows. Eu tenho um Mac, então usarei os comandos "gradlew".

Você pode emitir comandos Gradle de dentro do Android Studio:

• Na barra de ferramentas do Android Studio, selecione "Exibir> Ferramentas Windows> Terminal". Isso abre um painel Terminal na parte inferior da janela do IDE.
• Digite o seguinte comando no terminal:

./gradlew build

O Android Studio deve ser algo assim:

• Pressione a tecla “Enter” no seu teclado. Gradle agora criará seu projeto.

A Gradle armazena todos os APKs gerados no diretório app / build / outputs / apk do seu projeto, então navegue até esse diretório. A pasta “APK” deve conter várias pastas e subpastas; verifique se Gradle gerou um APK para cada uma das suas variantes de criação e se as informações corretas de data e hora foram adicionadas a cada arquivo.

Que outras tarefas Gradle estão disponíveis?

Além de quaisquer tarefas personalizadas que você possa criar, o Gradle suporta uma lista de tarefas predefinidas prontas para uso. Se você está curioso para ver exatamente quais tarefas estão disponíveis, então:

• Abra a janela Terminal do Android Studio, se ainda não estiver aberta (selecione "Exibir> Ferramentas Windows> Terminal" na barra de ferramentas do Android Studio).
• Digite o seguinte no terminal:

Tarefas ./gradlew -q

• Pressione a tecla “Enter” no seu teclado.

Esta tarefa de "tarefas" será executada e, após alguns instantes, o Terminal exibirá uma lista de todas as tarefas disponíveis para este projeto, com uma breve descrição de cada tarefa.

Aproveitando melhor o Gradle: adicionando plugins

A Gradle é fornecida com vários plugins pré-instalados, mas você pode estender ainda mais a Gradle adicionando novos plugins. Esses plug-ins disponibilizam novas tarefas para seus projetos Android, por exemplo, o plug-in Java inclui tarefas que permitem compilar o código-fonte Java, executar testes de unidade e criar um arquivo JAR, como "compileJava", "compileText", "jar", "Javadoc" e "limpo".

Para aplicar um plug-in, adicione a declaração “apply plugin” ao seu arquivo build.gradle no nível do módulo, seguido pelo nome do plug-in. Por exemplo, aqui estamos aplicando o plug-in Java:

aplicar plugin: java

Se você está curioso para saber quais plug-ins estão disponíveis, consulte a pesquisa do Gradle Plugin, que fornece um registro abrangente dos plug-ins do Gradle.

O DSL Gradle Kotlin

Por padrão, você escreve seus scripts de compilação Gradle usando o DSL Groovy, mas se você é um dos muitos desenvolvedores que adotaram o Kotlin para desenvolvimento para Android, pode preferir escrever seus scripts de compilação no Kotlin.

Ao contrário do Groovy, o Kotlin é uma linguagem de programação com estaticamente, portanto, se você mudar, seus arquivos de compilação serão compatíveis com os recursos de preenchimento automático e navegação de código fonte do Android Studio. Além disso, passar do Groovy para o Kotlin significa que você usará a mesma linguagem de programação em seu projeto, o que pode tornar o desenvolvimento mais direto - principalmente se você não estiver familiarizado demais com o Groovy!

Se você deseja começar a escrever sua lógica de construção no Kotlin, precisará configurar a DSL Gradle Kotlin e seguir as instruções no guia de migração.

Empacotando

Neste artigo, exploramos a ferramenta de automação de compilação e gerenciamento de dependência do Android Studio. Examinamos como o Gradle automatiza o processo de compilação imediatamente e como você pode modificá-lo editando os arquivos de compilação do Gradle do seu projeto, incluindo a criação de tarefas personalizadas da Gradle e a geração de várias variantes de compilação a partir de um único projeto.

Você estendeu o Gradle para automatizar outras partes do processo de criação do Android? Deixe-nos saber nos comentários abaixo!