O que é o Gradle no Android Studio?

Gradle é um pouco confuso para mim e também para qualquer novo desenvolvedor Android. Alguém pode explicar o que é Gradle no Android Studio e qual é o seu objetivo? Por que está incluído no Android Studio?

Resposta curta

Gradle é um sistema de compilação.

Resposta longa

Antes do Android Studio, você usava o Eclipse para fins de desenvolvimento e, provavelmente, você não sabia como criar seu APK do Android sem o Eclipse.

Você pode fazer isso na linha de comando, mas precisa aprender o que cada ferramenta (dx, aapt) faz no SDK. O Eclipse nos salvou de todos esses detalhes básicos, de baixo nível, mas importantes, fornecendo seu próprio sistema de construção.

Agora, você já se perguntou por que a respasta está no mesmo diretório da sua srcpasta?

É aqui que o sistema de compilação entra em cena. O sistema de compilação pega automaticamente todos os arquivos de origem ( .javaou .xml), depois aplica a ferramenta apropriada (por exemplo, pega javaos arquivos de classe e os converte em dexarquivos) e agrupa todos eles em um arquivo compactado, nosso amado APK.

Esse sistema de construção usa algumas convenções: um exemplo de um é especificar o diretório que contém os arquivos de origem (no Eclipse, é \srcpasta) ou arquivos de recursos (no Eclipse, é \respasta).

Agora, para automatizar todas essas tarefas, deve haver um script; você pode escrever seu próprio sistema de compilação usando scripts de shell no linux ou sintaxe de arquivos em lote no windows. Entendi?

Gradle é outro sistema de compilação que pega os melhores recursos de outros sistemas de compilação e os combina em um. É aprimorado com base em suas deficiências. É um sistema de construção baseado em JVM , o que significa que você pode escrever seu próprio script em Java, que o Android Studio utiliza.

Uma coisa interessante sobre o gradle é que ele é um sistema baseado em plugins . Isso significa que, se você possui sua própria linguagem de programação e deseja automatizar a tarefa de criar algum pacote (saída como um JAR para Java) a partir de fontes, é possível escrever um plug-in completo em Java ou Groovy (ou Kotlin, veja aqui ) e distribuí-lo para o resto do mundo.

Por que o Google usou?

O Google viu um dos sistemas de criação mais avançados do mercado e percebeu que era possível escrever scripts próprios com pouca ou nenhuma curva de aprendizado e sem aprender Groovy ou qualquer outro novo idioma. Então eles escreveram o plugin Android para Gradle.

Você deve ter visto build.gradlearquivo (s) em seu projeto. É aqui que você pode escrever scripts para automatizar suas tarefas. O código que você viu nesses arquivos é o código do Groovy. Se você escrever System.out.println("Hello Gradle!");, ele será impresso no seu console.

O que você pode fazer em um script de construção?

Um exemplo simples é que você precisa copiar alguns arquivos de um diretório para outro antes que o processo de compilação real ocorra. Um script de construção Gradle pode fazer isso.

É a nova ferramenta de compilação que o Google deseja usar para Android. Ele está sendo usado por ser mais extensível e útil que o ant. O objetivo é aprimorar a experiência do desenvolvedor.

Você pode assistir a uma palestra de Xavier Ducrohet da Equipe de desenvolvedores Android no Google I / O aqui.

Há também outra palestra no Android Studio de Xavier e Tor Norbye, também durante o Google I / O aqui .

Gradle é um sistema de compilação em execução no Android Studio .

Em outros idiomas, por exemplo:

• Formiga e Maven de Java
• Ancinho de Rubi
• AAP de C
• NAnt of .NET
• Faça no Linux

Aqui está uma explicação detalhada sobre o que Gradleé e como usá-lo no Android Studio.

Explorando os arquivos Gradle

1. Sempre que você cria um projeto no Android Studio, o sistema de compilação gera automaticamente todos os arquivos de compilação Gradle necessários.

Arquivos de compilação Gradle

2. Os arquivos de compilação Gradle usam a Domain Specific Language or DSLpara definir a lógica de compilação personalizada e interagir com os elementos específicos do Android do plug-in Android para Gradle.

3. Os projetos do Android Studio consistem em 1 ou mais módulos, que são componentes que você pode criar, testar e depurar independentemente. Cada módulo possui seu próprio arquivo de construção, portanto, todo projeto do Android Studio contém 2 tipos de arquivos de construção Gradle.

4. Arquivo de compilação de nível superior: é aqui que você encontrará as opções de configuração comuns a todos os módulos que compõem seu projeto.

5. Arquivo de compilação no nível do módulo : Cada módulo possui seu próprio arquivo de compilação Gradle que contém configurações de compilação específicas do módulo. Você passará a maior parte do tempo editando arquivos de construção no nível do módulo, em vez do arquivo de construção no nível superior do seu projeto.

Para dar uma olhada nesses build.gradlearquivos, abra o painel Projeto do Android Studio (selecionando a guia Projeto) e expanda a pasta Scripts Gradle. Os dois primeiros itens na pasta Scripts Gradle são os arquivos de construção Gradle no nível do projeto e no módulo

Arquivo de compilação de nível superior

Todo projeto do Android Studio contém um único arquivo de construção Gradle de nível superior. Este build.gradlearquivo é o primeiro item que aparece na pasta Scripts Gradle e está claramente marcado como Projeto.

Na maioria das vezes, você não precisará fazer alterações nesse arquivo, mas ainda é útil entender seu conteúdo e o papel que ele desempenha no seu projeto.

Arquivos de construção de gradação no nível do módulo

Além do arquivo de construção Gradle no nível do projeto, cada módulo possui um arquivo de construção Gradle próprio. Abaixo está uma versão anotada de um arquivo de construção Gradle básico no nível do módulo.

Outros arquivos Gradle

Além dos arquivos build.gradle, sua pasta Gradle Scripts contém alguns outros arquivos Gradle. Na maioria das vezes, você não precisará editar manualmente esses arquivos, pois eles serão atualizados automaticamente quando você fizer alterações relevantes no seu projeto. No entanto, é uma boa ideia entender o papel que esses arquivos desempenham no seu projeto.

gradle-wrapper.properties (versão Gradle)

Esse arquivo permite que outras pessoas criem seu código, mesmo que não tenham o Gradle instalado em suas máquinas. Este arquivo verifica se a versão correta do Gradle está instalada e baixa a versão necessária, se necessário.

settings.gradle

Este arquivo faz referência a todos os módulos que compõem seu projeto.

gradle.properties (propriedades do projeto)

Este arquivo contém informações de configuração para todo o seu projeto. Está vazio por padrão, mas você pode aplicar uma grande variedade de propriedades ao seu projeto adicionando-as a este arquivo.

local.properties (local do SDK)

Este arquivo informa ao plug-in Android Gradle, onde pode encontrar a instalação do Android SDK.

Nota: local.properties contém informações específicas para a instalação local do Android SDK. Isso significa que você não deve manter este arquivo sob controle de origem.

Leitura sugerida - Tutorial do Tutsplus

Eu tenho uma compreensão clara do gradle disso.

Gradle é um tipo de ferramenta de construção que constrói o código fonte do programa. Portanto, é uma parte importante do Android Studio e precisa ser instalado antes de começar a desenvolver seu aplicativo.

Não precisamos instalá-lo separadamente, porque o Android Studio faz isso por nós, quando fazemos nosso primeiro projeto.

DEFINIÇÃO :: Gradle pode ser descrito como um mecanismo de construção estruturado, em que fornece ao desenvolvedor as ferramentas e a flexibilidade para gerenciar os recursos de um projeto para criar construções que são smaller in size, targeting specific requirementspara certos dispositivos de determinadas configurações

CONFIGURAÇÕES BÁSICAS

1. minimumSdk
2. maximumSdk
3. targettedSdk
4. versionCode
5. versionName

BIBLIOTECAS :: Podemos adicionar bibliotecas Android ou quaisquer outras bibliotecas de terceiros, de acordo com os requisitos fáceis, o que foi uma tarefa tediosa anteriormente. Se a biblioteca não se encaixar no projeto existente, é mostrado ao desenvolvedor um log em que a pessoa pode encontrar uma solução apropriada para fazer alterações no projeto para que a biblioteca possa ser adicionada. É apenas uma linha de dependência

GERANDO VARIEDADES DE EDIFÍCIOS

Combinando tipos de construção com tipos de construção para obter variedades de variantes de construção

 ====================                         ====================
|     BuildTypes     |                       |   ProductFlavours  |
 --------------------  ====================== --------------------
|  Debug,Production  |      ||       ||      | Paid,Free,Demo,Mock|
 ====================       ||       ||       ==================== 
                            ||       ||
                            VV       VV
 =================================================================
|           DebugPaid, DebugFree, DebugDemo, DebugMock            |
|  ProductionPaid, ProductionFree, ProductionDemo, ProductionMock |
 =================================================================

REDUÇÃO DE TAMANHO

Gradle ajuda a reduzir o tamanho da compilação gerada, removendo os recursos não utilizados e os itens não utilizados das bibliotecas integradas

GERENCIAR PERMISSÕES

Podemos especificar determinadas permissões para certas compilações adicionando determinadas permissões em determinados cenários com base nos requisitos

EDIFÍCIOS PARA DETERMINADOS DISPOSITIVOS

Podemos gerenciar a geração de compilação para certos dispositivos que incluem determinadas densidades e determinados níveis de API. Isso ajuda na implantação de produtos na loja de aplicativos, de acordo com os requisitos em vários tipos de dispositivos

BOA REFERÊNCIA

Vogella Tutorials

Você pode encontrar tudo o que precisa saber sobre a Gradle aqui: Guia do usuário do Gradle Plugin

Objetivos do novo sistema de compilação

Os objetivos do novo sistema de compilação são:

• Facilite a reutilização de código e recursos
• Facilite a criação de várias variantes de um aplicativo, para distribuição multi-apk ou para diferentes tipos de aplicativo
• Facilite a configuração, a extensão e a personalização do processo de compilação
• Boa integração IDE

Por que Gradle?

Gradle é um sistema de construção avançado, bem como um kit de ferramentas de construção avançado, que permite criar lógica de construção personalizada por meio de plugins.

Aqui estão algumas das características que nos fizeram escolher o Gradle:

• Linguagem Específica de Domínio (DSL) para descrever e manipular a lógica de construção
• Os arquivos de compilação são baseados no Groovy e permitem a mistura de elementos declarativos por meio da DSL e usando o código para manipular os elementos DSL para fornecer lógica personalizada.
• Gerenciamento de dependência incorporado através do Maven e / ou Ivy.
• Muito flexível. Permite usar as melhores práticas, mas não força sua própria maneira de fazer as coisas.
• Os plug-ins podem expor seu próprio DSL e sua própria API para que os arquivos de construção sejam usados.
• Boa API de ferramentas que permite a integração do IDE

Refiro-me a dois tutoriais para escrever a resposta um , dois

Gradle é uma ferramenta de construção declarativa de uso geral. É de propósito geral, porque pode ser usado para criar praticamente qualquer coisa que você queira implementar no script de construção. É declarativo, pois você não deseja ver muito código no arquivo de construção, o que não é legível e é menos sustentável. Assim, embora Gradle forneça a ideia de convenções e uma construção simples e declarativa, também torna a ferramenta adaptável e os desenvolvedores a capacidade de estender. Ele também fornece uma maneira fácil de personalizar o comportamento padrão e ganchos diferentes para adicionar recursos de terceiros.

Gradle combina as partes boas de ambas as ferramentas e fornece recursos adicionais e usa o Groovy como uma linguagem específica de domínio (DSL). Possui poder e flexibilidade da ferramenta Ant com recursos do Maven, como o ciclo de vida da construção e a facilidade de uso.

Por que Gradle? Porque agora?

A resposta da ferramenta de construção é adicionar funcionalidade de script por meio de mecanismos de extensão não padrão. Você acaba misturando código de script com XML ou invocando scripts externos da sua lógica de construção. É fácil imaginar que você precisará adicionar mais e mais códigos personalizados ao longo do tempo. Como resultado, você inevitavelmente apresenta complexidade acidental, e a manutenção sai pela janela.

Digamos que você queira copiar um arquivo para um local específico ao criar a versão de lançamento do seu projeto. Para identificar a versão, verifique uma sequência nos metadados que descrevem seu projeto. Se corresponder a um esquema de numeração específico (por exemplo, 1.0-RELEASE), copie o arquivo do ponto A ao ponto B. De uma perspectiva externa, isso pode parecer uma tarefa trivial. Se você precisar confiar no XML, a linguagem de construção de muitas ferramentas tradicionais, expressar essa lógica simples, se tornará bastante difícil.

Evolução das ferramentas de compilação Java

A lógica de construção Java deve ser descrita em XML. O XML é ótimo para descrever dados hierárquicos, mas não consegue expressar o fluxo do programa e a lógica condicional. À medida que um script de construção cresce em complexidade, manter o código de construção se torna um pesadelo.

No Ant , você faz com que o destino JAR dependa do destino de compilação. Ant não fornece nenhuma orientação sobre como estruturar seu projeto. Embora permita flexibilidade máxima, o Ant torna cada script de construção exclusivo e difícil de entender. Bibliotecas externas exigidas pelo seu projeto geralmente são verificadas no controle de versão porque não há mecanismo automatizado para extraí-las de um local central.

O Maven 1 , lançado em julho de 2004, tentou facilitar esse processo. Ele forneceu um projeto e estrutura de diretório padronizados, bem como gerenciamento de dependências. Infelizmente, é difícil implementar lógica personalizada

Gradle se encaixa perfeitamente nessa geração de ferramentas de construção e atende a muitos requisitos das modernas ferramentas de construção (Figura 1). Ele fornece uma DSL expressiva, uma abordagem de convenção sobre configuração e um poderoso gerenciamento de dependências. É a decisão certa de abandonar o XML e apresentar a linguagem dinâmica Groovy para definir sua lógica de construção. Parece convincente, não é?

Gradle combina os melhores recursos de outras ferramentas de construção.

Conjunto de recursos atraentes de Gradle

Por que construir seus projetos Java com Gradle em vez de Ant ou Maven?

A ferramenta de construção padrão para Android (e a nova estrela das ferramentas de construção na JVM) foi projetada para facilitar o script de construções complexas em vários idiomas. Você deve mudar, se estiver usando Ant ou Maven?

A chave para desbloquear os recursos de energia do Gradle no seu script de construção está na descoberta e aplicação do modelo de domínio, conforme mostrado na imagem abaixo.

A Gradle não pode conhecer todos os requisitos específicos para a criação da sua empresa. Ao expor ganchos nas fases do ciclo de vida, o Gradle permite monitorar e configurar o comportamento de execução do script de construção.

Gradle estabelece um vocabulário para seu modelo, expondo uma DSL implementada no Groovy. Ao lidar com um domínio de problema complexo, nesse caso, a tarefa de criar software, poder usar uma linguagem comum para expressar sua lógica, pode ser uma ferramenta poderosa.

Outro exemplo é a maneira como você pode expressar dependências para bibliotecas externas, um problema muito comum resolvido por ferramentas de construção. Gradle pronto para uso fornece dois blocos de configuração para o script de construção que permitem definir as dependências e repositórios dos quais você deseja recuperá-los. Se os elementos DSL padrão não atenderem às suas necessidades, você poderá introduzir seu próprio vocabulário através do mecanismo de extensão de Gradle.

Integração com outras ferramentas de construção

Gradle joga bem com Ant, Maven e Ivy de seus antecessores, como mostra a imagem abaixo.

Automatizando seu projeto da compilação à implantação

Na imagem: estágios de um pipeline de implantação.

• Compilando o código

• Executando testes de unidade e integração

• Executando análise de código estático e gerando cobertura de teste

• Criando a distribuição

• Provisionando o Ambiente de Destino

• Implantando a entrega

• Realizando testes funcionais automatizados de fumaça

Refiro-me a dois tutoriais para escrever a resposta um , dois

Gradle é um sistema de compilação . Sistemas de construção são ferramentas de software projetadas para automatizar o processo de compilação de programas. Os sistemas de compilação vêm de várias formas e são usados ​​para uma variedade de tarefas de compilação de software. Embora seu principal objetivo seja criar com eficiência executáveis.

Outro termo relacionado é Automação de compilação, que é o processo de automatizar a criação de uma compilação de software e os processos associados, incluindo: compilar o código-fonte do computador em código binário, empacotar o código binário e executar testes automatizados.

São poucos os sistemas de compilação semelhantes para outros idiomas (veja a lista completa aqui ):

1. Apache Ant e Apache Maven - Java
2. sbt (Ferramenta de compilação simples) - para Scala (estrutura de reprodução etc.)
3. AAP - Ferramenta de compilação baseada em Python
4. Rake (Apache Builder) - Ruby
5. Leiningen for Clojure

Correndo o risco de ser discursivo, acho que por trás disso está a questão de por que a experiência do Android Studio / Gradle é tão ruim.

Experiência típica de Clojure:

• faça o download do projeto com as dependências listadas em project.clj.
• Leiningen recebe as dependências graças a Clojars e Maven.
• Projeto compila.

Experiência típica do Android Studio / Gradle:

• "Importar meu projeto Eclipse".
• OK projeto importado.
• Gradle está fazendo isso ... espera ... espera ... espera ... Gradle terminou.
• Compilar ... não é possível compilar porque não sei o que é um X / não consigo encontrar a biblioteca Y.

Não tenho certeza se isso é culpa de Gradle exatamente. Mas a "importação do projeto Eclipse" parece bastante esquisita. Apesar de toda a alegada sofisticação de Gradle e as virtudes de um sistema de compilação, o Android Studio parece não importar muito as dependências ou o processo de compilação do Eclipse.

Não informa quando falha na importação de um gráfico de dependência completo. O Android Studio não fornece ajuda ou dicas úteis sobre como resolver o problema. Ele não informa onde você pode procurar manualmente nas pastas do Eclipse. Não informa qual biblioteca parece estar faltando. Ou ajudá-lo a procurar no Maven etc. por eles.

Em 2016, coisas como Leiningen / Clojars, ou npm de node, ou pip de Python, ou o apkg Debian (e tenho certeza de que muitos gerenciadores de pacotes semelhantes para outras linguagens e sistemas) funcionam lindamente ... dependências ausentes são coisa do passado.

Exceto no Android. Agora, o Android Studio é o único lugar em que ainda pareço experimentar o inferno das dependências perdidas.

Estou inclinado a dizer que isso é culpa do Google. Eles quebraram o ecossistema do Android (e milhares de projetos / tutoriais on-line existentes do Android) quando decidiram mudar de Eclipse para o Android Studio / Gradle sem produzir um processo de conversão robusto. As pessoas cujos projetos trabalham no Eclipse não estão adaptando-as ao AS (provavelmente porque é uma dor para elas). E as pessoas que tentam usar esses projetos no AS estão enfrentando os mesmos problemas.

De qualquer forma, se Gradle é esse sistema de construção super poderoso, por que ainda estou gerenciando muitas outras dependências no gerenciador sdk? Por que um projeto que precisa, digamos, do ndk, pode especificar isso em seu arquivo Gradle, para que seja instalado e incorporado automaticamente quando necessário? Por que o NDK é especial? Da mesma forma para plataformas de destino? Por que estou instalando-os explicitamente no IDE, em vez de apenas verificar meu projeto com eles e ter tudo isso organizado para mim nos bastidores?

Gradle é um sistema de construção avançado, bem como um kit de ferramentas de construção avançado, que permite criar lógica de construção personalizada através de plugins!

Vantagens:

• DSL - idioma específico do domínio, baseado no groovy
• DAG - Gráfico Acíclico Dirigido
• Construções incrementais
• Modelo de domínio extensível
• Gradle está sempre atualizado
• Antes de uma tarefa estar sendo executada, Gradle tira um instantâneo da entrada e saída de sua tarefa.
• Caso o instantâneo tenha mudado ou não exista, Gralde executará novamente esta tarefa.

Entradas de manifesto

Através da DSL, é possível configurar as seguintes entradas de manifesto:

Variante de compilação

Por padrão, o plug-in Android configura automaticamente o projeto para criar uma versão de depuração e uma versão do aplicativo.

Dependências

1. Dependências locais:

Se você possui arquivos binários no sistema de arquivos local dos quais um módulo depende, como arquivos JAR, é possível declarar essas dependências no arquivo de construção para esse módulo.

2. Dependências remotas:

Primeiro, o repositório deve ser adicionado à lista e, em seguida, a dependência deve ser declarada de uma maneira que Maven ou Ivy declarem seus artefatos.

Gradle é para a linguagem Groovy JVM o que é ant para Java. Basicamente, é a ferramenta de construção do Groovy. Ao contrário do Ant, ele é baseado na linguagem Groovy completa. Você pode, por exemplo, escrever o código de script Groovy no script Gradle para fazer algo em vez de confiar em um idioma de domínio específico.

Não conheço a integração específica do IntelliJ, mas imagine que você possa "estender" o Groovy de forma que possa escrever primitivas específicas da linguagem "build" e elas se tornem parte da linguagem Groovy. (A metaprogramação de Groovy é toda uma discussão em si mesma.) O IntelliJ / Google poderia usar o Gradle para criar uma linguagem de construção de nível muito alto, mas é uma linguagem baseada em um padrão aberto e expansível.

Gradle é um kit de ferramentas de construção avançado para Android que gerencia dependências e permite definir lógica de construção personalizada. recursos são como

• Personalize, configure e estenda o processo de compilação.

• Crie vários APKs para seu aplicativo com recursos diferentes usando o mesmo projeto.

• Reutilize código e recursos.

referir

Gradle é um kit de ferramentas de construção automatizado que pode integrar-se a vários ambientes diferentes, não apenas para projetos Android.

Aqui estão algumas coisas que você pode fazer com o gradle.

• Configuração mínima necessária para novos projetos, porque o Gradle possui configurações padrão para seus projetos do Android Studio.

• Declaração de Dependência. Você pode declarar arquivos jar de dependência ou arquivos de biblioteca hospedados no servidor local ou remoto.

• Gradle gera automaticamente um diretório de teste e um APK de teste da fonte do seu projeto.

• Se você adicionar todas as informações necessárias, como keyPassworde keyAlias, ao arquivo de criação do Gradle, poderá usá-lo para gerar APKs assinados.

• O Gradle pode gerar vários APKs com pacotes diferentes e criar configurações a partir de um único módulo.

No Android Studio, o Gradle é uma ferramenta de compilação personalizada usada para compilar pacotes do Android (arquivos apk) gerenciando dependências e fornecendo lógica de compilação personalizada.

O arquivo APK (pacote de aplicativos Android) é um arquivo zip especialmente formatado que contém

• Código de bytes
• Recursos (imagens, interface do usuário, xml etc.)
• Arquivo de manifesto

Um arquivo apk é assinado e enviado ao dispositivo usando o ADB (Android Debug Bridge), onde é executado.

Gradle é uma ferramenta de compilação personalizada e usada para criar APK ou conhecido como kit de pacote de aplicativos.

por @Brian Gardner:

Gradle é uma extensa ferramenta de construção e gerenciador de dependências para projetos de programação. Ele possui um idioma específico de domínio baseado no Groovy. Gradle também fornece suporte por convenção para muitos tipos de projetos, incluindo Java, Android e Scala.

Recurso de Gradle:

1. Gerenciamento de Dependências
2. Usando Ant da Gradle
3. Gradle Plugins
4. Plugin Java
5. Plug-in Android
6. Construções de múltiplos projetos

Gradle é o que torna possível automatizar a criação de projetos Android complexos que envolvem milhares de linhas de código de várias fontes, projetos, bibliotecas etc. Ele pode gerar condicionalmente vários APKs otimizados com base em uma infinidade de especificações de configuração - se você estiver interessadas, as outras respostas fornecem mais detalhes sobre esse aspecto do Gradle.

No entanto, se você é novo no desenvolvimento do Android, Gradle em 99% dos casos é o que impede o desenvolvimento do seu projeto. É um sistema complexo e inescrutável que ofusca efetivamente o processo de compilação do Android e essencialmente o torna indisponível para desenvolvedores inexperientes, ou seja, para criar um aplicativo Android simples e de nível básico, o novato desavisado pode precisar estudar e entender muitas coisas pelas quais não negociou. tal como:

• Estrutura e ecossistema do APK do Android
• Android Studio
• Caminhos de classe e dependências Java
• Groovy
• Scripts de construção de gradle
• Muitas outras tecnologias complexas e interessantes

Todas essas coisas são interessantes e úteis para os desenvolvedores do Android saberem, mas estão longe de serem fáceis e apresentam uma barreira formidável à entrada. Eu suspeito que o que inspirou o OP a fazer essa pergunta é o sentimento de frustração que inevitavelmente atinge o desenvolvedor de neófitos depois de passar muito tempo tentando obter um aplicativo simples para construir e ser continuamente frustrado por Gradle. O problema é perversamente exacerbado pela enorme quantidade de documentação altamente técnica disponível para todas essas tecnologias. Também para uma grande quantidade de necessidades de desenvolvimento, Gradle é um exagero.

Uma alternativa é escrever um script de shell que constrói seu projeto automatizando as ferramentas disponíveis no SDK do Android. As virtudes dessa abordagem são muitas; para iniciantes, provavelmente é a melhor maneira de estudar e entender o processo de compilação e o ecossistema Android, além de permitir que você controle completamente como o aplicativo é construído. No entanto, essa abordagem é mais adequada para chefes de tecnologia profundamente irredimíveis do que para noobs inexperientes experimentando o Android.

O que é notável por sua ausência (por favor, informe-me se existe) é um IDE leve e de nível de entrada com um conjunto de recursos reduzido que simplifica simultaneamente o processo de compilação sem ocultá-lo (portanto, não netbeans ou eclipse) ele ainda poderia use Gradle (o que havia de errado com Ant). Deverá facilitar a geração de APKs que estejam em conformidade com algumas configurações comuns e usar uma estrutura de projeto que possa evoluir para um projeto completo do Android Studio, caso você decida fazer dessa maneira.

Em termos simples, o Gradle é uma ferramenta fornecida pelo Android Studio para implementar dois processos importantes:

1. Construa nossos projetos
2. Empacote AndroidManifest.xml, pasta res e código binário em um arquivo zip especialmente formatado chamado APK

Resultados da pesquisa Snippet em destaque da web Android | Construir. gradle. Gradle é um sistema de construção (código aberto) usado para automatizar construção, teste, implantação etc. ... Por exemplo, a tarefa simples de copiar alguns arquivos de um diretório para outro pode ser executada pelo script de construção da Gradle antes da construção real processo acontece.

No Android Studio, o Gradle é usado para criar nossos projetos de aplicativos para Android, desempenhando, portanto, o papel de um sistema de compilação. Antes do Android Studio, no Eclipse, costumávamos compilar e criar aplicativos usando a ferramenta de linha de comando, que logo foi assumida por etapas baseadas em GUI para criar e executar aplicativos Android no eclipse usando ANT. Toda ferramenta de desenvolvimento de aplicativos Android precisa compilar recursos, código-fonte java, bibliotecas externas e combiná-los em um APK final.

Gradle é um sistema de compilação, responsável pela compilação, teste, implantação e conversão do código em arquivos .dex e, portanto, executando o aplicativo no dispositivo.

Como o Android Studio vem com o sistema Gradle pré-instalado, não há necessidade de instalar softwares de tempo de execução adicionais para criar nosso projeto. Sempre que você clica em botão no android studio, uma tarefa gradle é acionada automaticamente e começa a compilar o projeto. Após a conclusão da tarefa, o aplicativo começa a ser executado no AVD ou no dispositivo conectado.

Um sistema de compilação como o Gradle não é um compilador, vinculador etc., mas controla e supervisiona a operação de compilação, vinculação de arquivos, execução de casos de teste e, eventualmente, agrupar o código em um arquivo apk para o seu aplicativo Android.

Existem dois arquivos build.gradle para cada projeto do android studio, um para aplicativos e outro para arquivos de construção no nível do projeto (nível do módulo) .

No processo de compilação, o compilador pega o código-fonte, os recursos, os arquivos JAR das bibliotecas externas e o AndroidManifest.xml (que contém os metadados sobre o aplicativo) e os converte em arquivos .dex (arquivos executáveis ​​do Dalvik) , que inclui o bytecode . Esse bytecode é suportado por todos os dispositivos Android para executar seu aplicativo. Em seguida, o APK Manager combina os arquivos .dex e todos os outros recursos em um único arquivo apk. O APK Packager assina depuração ou versão apk usando o respectivo keystore de depuração ou versão.

O apk de depuração geralmente é usado para fins de teste ou podemos dizer que é usado apenas no estágio de desenvolvimento. Quando seu aplicativo estiver completo com os recursos desejados e você estiver pronto para publicar seu aplicativo para uso externo, você precisará de um apk de Lançamento assinado usando um keystore de lançamento.

Agora vamos lançar alguma luz sobre os arquivos gradle.

setting.gradle O arquivo setting.gradle (configuração Gradle) é usado para especificar todos os módulos usados ​​no seu aplicativo.

build.gradle (nível do projeto) O arquivo build.gradle de nível superior (módulo) é um arquivo de construção no nível do projeto, que define configurações de construção no nível do projeto. Este arquivo aplica configurações a todos os módulos no projeto de aplicativo Android.

build.gradle (nível do aplicativo) O arquivo build.gradle no nível do aplicativo está localizado em cada módulo do projeto android. Esse arquivo inclui o nome do pacote como applicationID, nome da versão (versão apk), código da versão, sdk mínimo e de destino para um módulo de aplicativo específico. Ao incluir bibliotecas externas (não os arquivos jar), é necessário mencioná-lo no arquivo gradle no nível do aplicativo para incluí-las no seu projeto como dependências do aplicativo.

Nota: Se um determinado aplicativo for desenvolvido em variações para módulos individuais como Smart Phone, Tablet ou TV, arquivos gradle separados deverão ser criados para todos. Você pode até iniciar seu sistema de nivelamento através da ferramenta de linha de comando . Os seguintes comandos são usados ​​para isso:

./gradlew build - (projeto de construção)
./gradlew build limpo - (projeto completo de compilação)
./gradlew build limpo - (execute o teste)
./gradlew wrapper - (para ver todas as tarefas disponíveis)

Gradle = Suporte para Groovy + Berço Hans Dockter

A confusão é um pouco desnecessária quando poderia ter sido chamada de "Build" ou algo no Android Studio.

Gostamos de tornar as coisas difíceis para nós mesmos na comunidade de desenvolvimento.