Gradle è un po 'confuso per me e anche per qualsiasi nuovo sviluppatore Android. Qualcuno può spiegare cos'è Gradle in Android Studio e qual è il suo scopo? Perché è incluso in Android Studio?
Gradle è un po 'confuso per me e anche per qualsiasi nuovo sviluppatore Android. Qualcuno può spiegare cos'è Gradle in Android Studio e qual è il suo scopo? Perché è incluso in Android Studio?
Risposte:
Gradle è un sistema di generazione.
Prima di Android Studio utilizzavi Eclipse per i tuoi scopi di sviluppo e, probabilmente, non sapevi come creare il tuo APK Android senza Eclipse.
Puoi farlo dalla riga di comando, ma devi imparare cosa fa ogni strumento (dx, aapt) nell'SDK. Eclipse ci ha salvati tutti da questi dettagli di basso livello ma importanti, fondamentali dandoci il loro sistema di costruzione.
Ora, ti sei mai chiesto perché la res
cartella si trova nella stessa directory della tua src
cartella?
Qui è dove il sistema di compilazione entra in scena. Il sistema di compilazione prende automaticamente tutti i file di origine ( .java
o .xml
), quindi applica lo strumento appropriato (ad es. Prende java
i file di classe e li converte in dex
file) e li raggruppa in un unico file compresso, il nostro amato APK.
Questo sistema di compilazione utilizza alcune convenzioni: un esempio è quello di specificare la directory contenente i file di origine (in Eclipse è la \src
cartella) o i file di risorse (in Eclipse è\res
cartella).
Ora, per automatizzare tutte queste attività, ci deve essere uno script; puoi scrivere il tuo sistema di compilazione usando lo shell scripting in Linux o la sintassi dei file batch in Windows. Fatto?
Gradle è un altro sistema di build che prende le migliori funzionalità da altri sistemi di build e le combina in una sola. È migliorato in base alle loro carenze. È un sistema di build basato su JVM , ciò significa che puoi scrivere il tuo script in Java, utilizzato da Android Studio.
Una cosa interessante di Gradle è che si tratta di un sistema basato su plugin . Questo significa che se hai il tuo linguaggio di programmazione e vuoi automatizzare il compito di costruire un pacchetto (output come un JAR per Java) dai sorgenti, puoi scrivere un plugin completo in Java o Groovy (o Kotlin, vedi qui ), e distribuirlo nel resto del mondo.
Google ha visto uno dei sistemi di build più avanzati sul mercato e si è reso conto che potevi scrivere i tuoi script con una curva di apprendimento minima o nulla e senza imparare Groovy o qualsiasi altra nuova lingua. Quindi hanno scritto il plug-in Android per Gradle.
Devi aver visto i build.gradle
file nel tuo progetto. È qui che puoi scrivere script per automatizzare le tue attività. Il codice che hai visto in questi file è il codice Groovy. Se scriviSystem.out.println("Hello Gradle!");
, verrà stampato sulla tua console.
Un semplice esempio è che è necessario copiare alcuni file da una directory all'altra prima che avvenga il processo di compilazione effettivo. Uno script build Gradle può fare questo.
È il nuovo strumento di creazione che Google vuole utilizzare per Android. Viene utilizzato perché è più estensibile e utile della formica. È pensato per migliorare l'esperienza degli sviluppatori.
Puoi visualizzare un discorso di Xavier Ducrohet del team di sviluppatori Android su I / O di Google qui.
C'è anche un altro discorso su Android Studio di Xavier e Tor Norbye, anche durante l'I / O di Google qui .
Gradle è un sistema di generazione in esecuzione su Android Studio .
In altre lingue, ad esempio:
Gradle
è simile a make
, ho appena avuto il suo concetto
Ecco una spiegazione dettagliata di cosa Gradle
sia e come utilizzarlo in Android Studio.
Esplorare i file Gradle
Gradle Build Files
I file di build Gradle utilizzano a Domain Specific Language or DSL
per definire la logica di build personalizzata e per interagire con gli elementi specifici di Android del plug-in Android per Gradle.
I progetti Android Studio sono composti da 1 o più moduli, che sono componenti che è possibile creare, testare ed eseguire il debug in modo indipendente. Ogni modulo ha il proprio file di build, quindi ogni progetto Android Studio contiene 2 tipi di file di build Gradle.
File di build di primo livello: qui troverai le opzioni di configurazione comuni a tutti i moduli che compongono il tuo progetto.
File di build a livello di modulo : ogni modulo ha il proprio file di build Gradle che contiene impostazioni di build specifiche del modulo. Trascorrerai la maggior parte del tempo a modificare i file di build a livello di modulo anziché i file di build di livello superiore del tuo progetto.
Per dare un'occhiata a questi build.gradle
file, apri il pannello Progetto di Android Studio (selezionando la scheda Progetto) ed espandi la cartella Gradle Scripts. I primi due elementi nella cartella Gradle Scripts sono i file di build Gradle a livello di progetto e di modulo
File di costruzione di livello superiore
Ogni progetto di Android Studio contiene un singolo file di build Gradle di livello superiore. Questo build.gradle
file è il primo elemento che appare nella cartella Gradle Scripts ed è chiaramente contrassegnato come Progetto.
Il più delle volte, non sarà necessario apportare modifiche a questo file, ma è comunque utile comprenderne il contenuto e il ruolo che svolge all'interno del progetto.
File di build di livello a livello di modulo
Oltre al file di build Gradle a livello di progetto, ogni modulo ha un proprio file di build Gradle. Di seguito è riportata una versione annotata di un file di build Gradle di base a livello di modulo.
Altri file di gradi
Oltre ai file build.gradle, la cartella Script Gradle contiene altri file Gradle. Il più delle volte non sarà necessario modificare manualmente questi file poiché verranno aggiornati automaticamente quando si apportano modifiche rilevanti al progetto. Tuttavia, è una buona idea capire il ruolo di questi file all'interno del tuo progetto.
gradle-wrapper.properties (versione di livello)
Questo file consente ad altre persone di creare il tuo codice, anche se non hanno Gradle installato sul proprio computer. Questo file controlla se è installata la versione corretta di Gradle e, se necessario, scarica la versione necessaria.
settings.gradle
Questo file fa riferimento a tutti i moduli che compongono il tuo progetto.
gradle.properties (Proprietà del progetto)
Questo file contiene informazioni di configurazione per l'intero progetto. È vuoto per impostazione predefinita, ma è possibile applicare una vasta gamma di proprietà al progetto aggiungendole a questo file.
local.properties (posizione SDK)
Questo file indica al plug-in Android Gradle dove è possibile trovare l'installazione dell'SDK di Android.
Nota: local.properties
contiene informazioni specifiche per l'installazione locale di Android SDK. Ciò significa che non dovresti tenere questo file sotto il controllo del codice sorgente.
Lettura consigliata - Tutsplus Tutorial
Ho avuto una chiara comprensione del grado da questo.
Gradle è un tipo di strumento di creazione che crea il codice sorgente del programma. Quindi è una parte importante di Android Studio e deve essere installata prima di iniziare a sviluppare l'applicazione.
Non è necessario installarlo separatamente, perché Android Studio lo fa per noi, quando realizziamo il nostro primo progetto.
DEFINIZIONE :: Gradle può essere descritto come un meccanismo di costruzione strutturato in cui fornisce allo sviluppatore gli strumenti e la flessibilità per gestire le risorse di un progetto per creare build che sono smaller in size
, targeting specific requirements
per alcuni dispositivi di determinate configurazioni
CONFIGURAZIONI DI BASE
minimumSdk
maximumSdk
targettedSdk
versionCode
versionName
BIBLIOTECHE :: Possiamo aggiungere anche librerie Android o qualsiasi altra libreria di terze parti secondo i requisiti facili che era un compito noioso in precedenza. Se la libreria non è adatta al progetto esistente, allo sviluppatore viene mostrato un registro in cui la persona può trovare una soluzione appropriata per apportare modifiche al progetto in modo da poter aggiungere la libreria. È solo una linea di dipendenza
GENERAZIONE DI VARIETÀ DI COSTRUZIONI
Combinazione di tipi di build con sapori di build per ottenere varietà di varianti di build
==================== ====================
| BuildTypes | | ProductFlavours |
-------------------- ====================== --------------------
| Debug,Production | || || | Paid,Free,Demo,Mock|
==================== || || ====================
|| ||
VV VV
=================================================================
| DebugPaid, DebugFree, DebugDemo, DebugMock |
| ProductionPaid, ProductionFree, ProductionDemo, ProductionMock |
=================================================================
DIMENSIONE RIDUCENTE
Gradle aiuta a ridurre le dimensioni della build generata rimuovendo le risorse non utilizzate e le cose non utilizzate dalle librerie integrate
GESTIONE DELLE AUTORIZZAZIONI
Possiamo specificare determinate autorizzazioni per determinati build aggiungendo determinate autorizzazioni in determinati scenari in base ai requisiti
COSTRUISCE PER TALUNI DISPOSITIVI
Siamo in grado di gestire la generazione di build per determinati dispositivi che includono determinate densità e determinati livelli di API. Questo aiuta nelle distribuzioni di prodotti nell'App Store in base ai requisiti su più tipi di dispositivi
BUON RIFERIMENTO
Puoi trovare tutto ciò che devi sapere su Gradle qui: Guida dell'utente del plug-in Gradle
Obiettivi del nuovo sistema di costruzione
Gli obiettivi del nuovo sistema di costruzione sono:
- Semplifica il riutilizzo di codice e risorse
- Semplifica la creazione di diverse varianti di un'applicazione, per la distribuzione multi-apk o per diversi gusti di un'applicazione
- Semplifica la configurazione, l'estensione e la personalizzazione del processo di compilazione
- Buona integrazione IDE
Perché Gradle?
Gradle è un sistema di build avanzato e un toolkit di build avanzato che consente di creare logiche di build personalizzate tramite plug-in.
Ecco alcune delle sue caratteristiche che ci hanno fatto scegliere Gradle:
- Domain Specific Language (DSL) per descrivere e manipolare la logica di compilazione
- I file di build sono basati su Groovy e consentono il mix di elementi dichiarativi attraverso il DSL e l'uso del codice per manipolare gli elementi DSL per fornire una logica personalizzata.
- Gestione integrata delle dipendenze tramite Maven e / o Ivy.
- Molto flessibile. Permette di usare le migliori pratiche ma non impone il proprio modo di fare le cose.
- I plug-in possono esporre il proprio DSL e la propria API per i file di build da utilizzare.
- Buona API Tooling che consente l'integrazione IDE
Mi riferisco a due tutorial per scrivere la risposta uno , due
Gradle è uno strumento di costruzione dichiarativo generico. È generico perché può essere utilizzato per creare praticamente tutto ciò che ti interessa implementare nello script di compilazione. È dichiarativo poiché non si desidera visualizzare un sacco di codice nel file di build, che non è leggibile e meno gestibile. Pertanto, sebbene Gradle fornisca l'idea di convenzioni e una costruzione semplice e dichiarativa, rende anche lo strumento adattabile e gli sviluppatori la possibilità di estendere. Fornisce inoltre un modo semplice per personalizzare il comportamento predefinito e diversi hook per aggiungere funzionalità di terze parti.
Gradle combina le parti positive di entrambi gli strumenti e fornisce funzionalità aggiuntive e utilizza Groovy come DSL (Domain Specific Language). Ha la potenza e la flessibilità dello strumento Ant con funzionalità Maven come il ciclo di vita della build e la facilità d'uso.
Perché Gradle? Perché ora?
La risposta dello strumento di compilazione è quella di aggiungere funzionalità di scripting tramite meccanismi di estensione non standard. Si finisce per mescolare il codice di scripting con XML o invocare script esterni dalla logica di compilazione. È facile immaginare che dovrai aggiungere sempre più codice personalizzato nel tempo. Di conseguenza, si introduce inevitabilmente complessità accidentale e la manutenibilità esce dalla finestra.
Supponiamo che tu voglia copiare un file in una posizione specifica quando crei la versione di rilascio del tuo progetto. Per identificare la versione, controlli una stringa nei metadati che descrivono il tuo progetto. Se corrisponde a uno schema di numerazione specifico (ad esempio, 1.0-RELEASE), si copia il file dal punto A al punto B. Da una prospettiva esterna, questo può sembrare un compito banale. Se devi fare affidamento su XML, il linguaggio di costruzione di molti strumenti tradizionali, esprimere questa semplice logica diventa abbastanza difficile.
Evoluzione di Java Build Tools
La logica di compilazione Java deve essere descritta in XML. XML è ottimo per descrivere i dati gerarchici ma non riesce a esprimere il flusso del programma e la logica condizionale. Man mano che lo script di compilazione cresce in complessità, mantenere il codice di costruzione diventa un incubo.
In Ant , fai in modo che il target JAR dipenda dal target di compilazione. Ant non fornisce alcuna guida su come strutturare il tuo progetto. Sebbene permetta la massima flessibilità, Ant rende ogni script di build unico e difficile da capire. Le librerie esterne richieste dal progetto vengono generalmente controllate nel controllo versione perché non esiste un meccanismo automatizzato per estrarle da una posizione centrale.
Maven 1 , rilasciato nel luglio 2004, ha cercato di facilitare questo processo. Ha fornito un progetto standardizzato e una struttura di directory, nonché una gestione delle dipendenze. Sfortunatamente, la logica personalizzata è difficile da implementare
Gradle si adatta perfettamente a quella generazione di strumenti di costruzione e soddisfa molti requisiti dei moderni strumenti di costruzione (Figura 1). Fornisce un DSL espressivo, una convenzione sull'approccio alla configurazione e una potente gestione delle dipendenze. Fa la mossa giusta per abbandonare XML e introdurre il linguaggio dinamico Groovy per definire la tua logica di costruzione. Sembra avvincente, vero?
Gradle combina le migliori caratteristiche di altri strumenti di costruzione.
Gradle's convincente set di funzionalità
Perché costruire i tuoi progetti Java con Gradle piuttosto che Ant o Maven?
Lo strumento di creazione predefinito per Android (e la nuova stella degli strumenti di creazione sulla JVM) è progettato per facilitare lo scripting di build complesse e multilingue. Dovresti cambiarlo, però, se stai usando Ant o Maven?
La chiave per sbloccare le funzionalità di potenza di Gradle all'interno del tuo script di compilazione sta nel scoprire e applicare il suo modello di dominio, come mostrato nell'immagine qui sotto.
Gradle non può conoscere tutti i requisiti specifici della tua build aziendale. Esponendo gli hook nelle fasi del ciclo di vita, Gradle consente il monitoraggio e la configurazione del comportamento di esecuzione dello script di build.
Gradle stabilisce un vocabolario per il suo modello esponendo un DSL implementato in Groovy. Quando si ha a che fare con un dominio problematico complesso, in questo caso il compito di creare software, essere in grado di usare un linguaggio comune per esprimere la propria logica può essere uno strumento potente.
Un altro esempio è il modo in cui è possibile esprimere dipendenze da librerie esterne, un problema molto comune risolto dagli strumenti di compilazione. Gradle out-of-the-box fornisce due blocchi di configurazione per lo script di compilazione che consentono di definire le dipendenze e i repository da cui si desidera recuperarli. Se gli elementi DSL standard non soddisfano le tue esigenze, puoi persino introdurre il tuo vocabolario attraverso il meccanismo di estensione di Gradle.
Integrazione con altri strumenti di costruzione
Gradle gioca bene con i suoi predecessori 'Ant, Maven e Ivy, come mostrato nell'immagine qui sotto.
Automatizzare il tuo progetto dalla costruzione alla distribuzione
Nell'immagine: fasi di una pipeline di distribuzione.
Compilare il codice
Esecuzione di test unitari e di integrazione
Esecuzione dell'analisi del codice statico e generazione della copertura del test
Creare la distribuzione
Provisioning dell'ambiente di destinazione
Distribuzione del deliverable
Esecuzione di fumo e test funzionali automatizzati
Mi riferisco a due tutorial per scrivere la risposta uno , due
Gradle è un sistema di generazione . I sistemi di build sono strumenti software progettati per automatizzare il processo di compilazione del programma. I sistemi di build sono disponibili in varie forme e vengono utilizzati per una varietà di attività di build del software. Mentre il loro obiettivo principale è quello di creare in modo efficiente eseguibili.
Un altro termine correlato è Build automation, che è il processo di automazione della creazione di una build software e dei processi associati tra cui: compilazione del codice sorgente del computer in codice binario, impacchettamento del codice binario ed esecuzione di test automatizzati.
Pochi sistemi di compilazione simili per altre lingue sono (vedi l'elenco completo qui ):
A rischio di essere discorsivo, penso che dietro questa sia la domanda sul perché l'esperienza Android Studio / Gradle sia così negativa.
Esperienza tipica di Clojure:
Esperienza tipica di Android Studio / Gradle:
Non sono sicuro che sia esattamente colpa di Gradle. Ma l '"importazione dal progetto Eclipse" sembra piuttosto traballante. Nonostante tutta la presunta raffinatezza di Gradle e le virtù di un sistema di build, Android Studio non sembra importare molto bene le dipendenze di build o il processo di build da Eclipse.
Non ti dice quando non è riuscito a importare un grafico completo delle dipendenze. Android Studio non fornisce aiuto o suggerimenti utili su come risolvere il problema. Non ti dice dove puoi cercare manualmente nelle cartelle Eclipse. Non ti dice quale libreria sembra mancare. O aiutarti a cercare Maven ecc. Per loro.
Nel 2016 cose come Leiningen / Clojars, o npm del nodo, o pip di Python, o l'apkg Debian (e sono sicuro che molti gestori di pacchetti simili per altri linguaggi e sistemi) funzionano tutti magnificamente ... le dipendenze mancanti sono un ricordo del passato.
Tranne con Android. Android Studio è ora l'unico posto in cui sembro ancora sperimentare l'inferno della mancanza di dipendenza.
Sono propenso a dire che è colpa di Google. Hanno rotto l'ecosistema Android (e migliaia di progetti Android / tutorial online esistenti) quando hanno deciso cavallermente di passare da Eclipse ad Android Studio / Gradle senza produrre un solido processo di conversione. Le persone i cui progetti funzionano in Eclipse non li stanno adattando ad AS (presumibilmente perché è un dolore per loro). E le persone che cercano di utilizzare quei progetti in AS stanno riscontrando gli stessi problemi.
E comunque, se Gradle è questo sistema di generazione super potente, perché sto ancora gestendo molte altre dipendenze nel gestore SDK? Perché un progetto che ha bisogno, per esempio, di ndk non lo specifica nel suo file Gradle in modo che venga automaticamente installato e integrato quando necessario? Perché NDK è speciale? Allo stesso modo per piattaforme target? Perché li sto installando esplicitamente nell'IDE piuttosto che semplicemente controllando il mio progetto contro di loro e avendo tutto questo ordinato per me dietro le quinte?
Gradle
è un sistema di build avanzato e un toolkit di build avanzato che consente di creare logiche di build personalizzate tramite plug-in!
vantaggi:
Voci manifest
Tramite il DSL è possibile configurare le seguenti voci manifest:
Crea variante
Per impostazione predefinita, il plug-in Android imposta automaticamente il progetto per creare sia una versione di debug che una versione dell'applicazione.
dipendenze
Se nel file system locale sono presenti archivi binari da cui dipende un modulo, come i file JAR, è possibile dichiarare queste dipendenze nel file di build per quel modulo.
Innanzitutto il repository deve essere aggiunto all'elenco, quindi la dipendenza deve essere dichiarata in modo tale che Maven o Ivy dichiarino i loro artefatti.
Gradle è nel linguaggio Groovy JVM ciò che la formica è per Java. Fondamentalmente, è lo strumento di costruzione di Groovy. A differenza di Ant, è basato sul linguaggio Groovy completo. Ad esempio, puoi scrivere il codice di script Groovy nello script Gradle per fare qualcosa invece di fare affidamento su una lingua di dominio specifica.
Non conosco l'integrazione specifica di IntelliJ, ma immagino che potresti "estendere" Groovy in modo tale da poter scrivere primitive linguistiche specifiche "build" e che diventino parte del linguaggio Groovy. (La metaprogrammazione di Groovy è una discussione a sé stante.) IntelliJ / Google potrebbe usare Gradle per costruire un linguaggio di costruzione di altissimo livello, tuttavia, è un linguaggio costruito su uno standard aperto e espandibile.
Gradle è un toolkit di build avanzato per Android che gestisce le dipendenze e consente di definire una logica di build personalizzata. le caratteristiche sono come
Personalizza, configura ed estendi il processo di compilazione.
Crea più APK per la tua app con funzionalità diverse utilizzando lo stesso progetto.
Riutilizzare codice e risorse.
Gradle è un toolkit di build automatizzato che può integrarsi in molti ambienti diversi non solo per i progetti Android.
Ecco alcune cose che puoi fare con Gradle.
Configurazione minima richiesta per i nuovi progetti perché Gradle ha configurazioni predefinite per i tuoi progetti Android Studio.
Dichiarazione di dipendenza. È possibile dichiarare file jar di dipendenza o file di libreria ospitati su un server locale o remoto.
Gradle genera automaticamente una directory di test e un APK di test dalla sorgente del progetto.
Se aggiungi tutte le informazioni necessarie, come keyPassword
e keyAlias
, al tuo file di build Gradle, puoi utilizzare Gradle per generare APK firmati.
Gradle può generare più APK con pacchetto diverso e creare configurazioni da un singolo modulo.
In Android Studio, Gradle è uno strumento di creazione personalizzato utilizzato per creare pacchetti Android (file apk) gestendo le dipendenze e fornendo una logica di creazione personalizzata.
Il file APK (pacchetto dell'applicazione Android) è un file zip appositamente formattato che contiene
Un file apk viene firmato e inviato al dispositivo tramite ADB (Android Debug Bridge) dove viene eseguito.
Gradle è uno strumento di creazione personalizzato e utilizzato per la creazione di APK o noto come kit di pacchetti di applicazioni.
di @Brian Gardner:
Gradle è uno strumento di compilazione esteso e gestore delle dipendenze per i progetti di programmazione. Ha un linguaggio specifico per il dominio basato su Groovy. Gradle fornisce anche supporto build-by-convention per molti tipi di progetti tra cui Java, Android e Scala.
Caratteristica di Gradle:
Gradle è ciò che rende possibile automatizzare la costruzione di progetti Android complessi che coinvolgono decine di migliaia di righe di codice da più fonti, progetti, librerie ecc. Può generare condizionalmente più APK ottimizzati basati su una pletora di specifiche di configurazione - se lo sei interessati, le altre risposte forniscono maggiori dettagli su questo aspetto di Gradle.
Tuttavia, se non conosci lo sviluppo di Android, Gradle nel 99% dei casi è ciò che impedisce la realizzazione del tuo progetto. Si tratta di un sistema imperscrutabile e complesso che offusca efficacemente il processo di generazione di Android e lo rende sostanzialmente non disponibile per sviluppatori inesperti, vale a dire per creare una semplice app per Android entry-level il neofita ignaro potrebbe aver bisogno di studiare e comprendere molte cose per le quali non si sono contratte ad esempio:
Tutte queste cose sono interessanti e utili per gli sviluppatori Android, ma sono tutt'altro che facili e rappresentano una formidabile barriera all'ingresso. Ho il sospetto che ciò che ha ispirato l'OP a porre questa domanda sia la sensazione di frustrazione che inevitabilmente colpisce lo sviluppatore di neofiti dopo aver trascorso troppo tempo a cercare di ottenere un'app semplice da costruire ed essere continuamente contrastato da Gradle. Il problema è aggravato perversamente dall'enorme quantità di documentazione altamente tecnica disponibile per tutte queste tecnologie. Anche per una grande quantità di esigenze di sviluppo Gradle è eccessivo.
Un'alternativa è scrivere uno script di shell che costruisce il tuo progetto automatizzando gli strumenti disponibili nell'SDK Android. Le virtù di questo approccio sono molte, per cominciare è probabilmente il modo migliore per studiare e comprendere il processo di compilazione e l'ecosistema Android e ti consente di controllare completamente come è costruita l'app. Tuttavia, questo approccio è più adatto per i capi tecnicamente profondamente irredimibili di quanto non lo sia per i non esperti che provano Android.
Ciò che è evidente per la sua assenza (per favore informami se c'è una cosa del genere) è un IDE entry-level, leggero con un set di funzionalità ridotto che semplifica simultaneamente il processo di generazione senza oscurarlo (quindi non netbeans o eclissi) che potrebbe ancora usa Gradle (cosa c'era di sbagliato in Ant). Dovrebbe facilitare la generazione di APK conformi a poche configurazioni comuni e l'uso di una struttura di progetto che può evolversi in un progetto Android Studio completo se decidi di prenderlo in quel modo.
In parole povere, Gradle è uno strumento fornito da Android Studio per implementare due processi importanti:
Risultati della ricerca Snippet in primo piano dal Web Android | costruire. Gradle. Gradle è un sistema di compilazione (open source) che viene utilizzato per automatizzare la costruzione, i test, la distribuzione, ecc ... Ad esempio, la semplice attività di copiare alcuni file da una directory all'altra può essere eseguita dallo script di compilazione Gradle prima della compilazione effettiva il processo accade.
In Android Studio, Gradle viene utilizzato per costruire i nostri progetti di applicazioni Android, quindi interpretando il ruolo di un sistema di generazione. Prima di Android Studio, in Eclipse eravamo soliti compilare e costruire le applicazioni utilizzando lo strumento da riga di comando che è stato presto ripreso dai passaggi basati sulla GUI per creare ed eseguire applicazioni Android in eclipse usando ANT. Ogni strumento di sviluppo di applicazioni Android deve compilare risorse, codice sorgente Java, librerie esterne e combinarle in un APK finale.
Gradle è un sistema di compilazione, che è responsabile della compilazione del codice, test, distribuzione e conversione del codice in file .dex e quindi eseguire l'app sul dispositivo.
Poiché Android Studio viene fornito con il sistema Gradle preinstallato, non è necessario installare software di runtime aggiuntivi per costruire il nostro progetto. Ogni volta che fai clic su pulsante in Android Studio, un'attività gradle si avvia automaticamente e inizia a costruire il progetto e dopo che Gradle ha completato la sua attività, l'app inizia a funzionare in AVD o nel dispositivo collegato.
Un sistema di compilazione come Gradle non è un compilatore, un linker ecc., Ma controlla e supervisiona le operazioni di compilazione, collegamento di file, esecuzione di casi di test e infine raggruppamento del codice in un file apk per la tua applicazione Android.
Esistono due file build.gradle per ogni progetto Android Studio, uno per l' applicazione e l'altro per i file di build a livello di progetto (a livello di modulo) .
Nel processo di compilazione, il compilatore prende il codice sorgente, le risorse, i file JAR delle librerie esterne e AndroidManifest.xml (che contiene i metadati sull'applicazione) e li converte in file .dex (file eseguibili di Dalvik) , che include bytecode . Tale bytecode è supportato da tutti i dispositivi Android per eseguire la tua app. Quindi APK Manager combina i file .dex e tutte le altre risorse in un singolo file apk. APK Packager firma l' apk di debug o di rilascio usando il rispettivo keystore di debug o rilascio.
L' apk di debug viene generalmente utilizzato a scopo di test o possiamo dire che viene utilizzato solo in fase di sviluppo. Quando l'app è completa delle funzionalità desiderate e si è pronti a pubblicare l'applicazione per uso esterno, è necessario un apk di rilascio firmato utilizzando un keystore di rilascio.
Ora facciamo luce sui file gradle.
setting.gradle Il file setting.gradle (impostazione Gradle) viene utilizzato per specificare tutti i moduli utilizzati nella tua app.
build.gradle (livello di progetto) Il file di livello superiore (modulo) build.gradle è un file di build a livello di progetto, che definisce le configurazioni di build a livello di progetto. Questo file applica le configurazioni a tutti i moduli nel progetto dell'applicazione Android.
build.gradle (livello applicazione) Il file build.gradle a livello applicazione si trova in ciascun modulo del progetto Android. Questo file include il nome del pacchetto come applicationID, il nome della versione (versione apk), il codice della versione, lo sdk minimo e di destinazione per un modulo dell'applicazione specifico. Quando si includono librerie esterne (non i file jar), è necessario menzionarlo nel file di valutazione a livello di app per includerle nel progetto come dipendenze dell'applicazione.
Nota: se una determinata applicazione viene sviluppata in varianti per singoli moduli come Smart Phone, Tablet o TV, è necessario creare file di valutazione separati per tutti. Puoi persino avviare il tuo sistema di pendenza tramite lo strumento da riga di comando . A tale scopo vengono utilizzati i seguenti comandi:
./gradlew build - (progetto build)
./gradlew clean build - (progetto build scratch completo)
./gradlew clean build - (esegui il test)
./gradlew wrapper - (per vedere tutte le attività disponibili)
Gradle = Groovy + Cradle Hans Dockter commento del forum
La confusione è un po 'superflua quando potrebbe essere stata appena chiamata "Build" o qualcosa di simile in Android Studio.
Ci piace rendere le cose difficili per noi stessi nella comunità dello sviluppo.